COLM 2026 Paper Finds the ‘I’m Just an AI’ Disclaimer Switch in LLMs

⏱️ Reading time: 10 min

Ask a language model to talk about itself and you’ll probably hear something like ‘I’m just a language model, I don’t have feelings.’ A paper published on August 9, 2026 shows that this phrase depends less on the model itself than on an invisible formatting detail: the chat template. When that token wrapper is present, the AI self-referential voice kicks in; when it’s absent, the same model speaks in the first person as if it felt something.

📑 En este artículo

1. TL;DR
2. What the chat template is
3. What happened
4. Context and background
5. Technical details and performance
6. How to test it
7. Impact: what this means for AI self-referential voice
8. What’s next
9. Frequently Asked Questions
   1. What is AI self-referential voice?
   2. Why does the chat template change a model’s disclaimer voice?
   3. What models did the researchers test?
   4. Can activation steering be applied without access to the full weights?
   5. Does this prove whether models are conscious?
   6. Where can I read the full paper?
10. References

The finding matters because much of the debate about introspection in models relies on what they say about themselves. If that discourse changes based on a formatting detail, it stops being reliable data and becomes a deployment artifact.

TL;DR

• An August 2026 paper shows that the chat template controls the AI self-referential voice in instruction-tuned models.
• They tested 8 open source instruction models with up to 9B parameters, and the pattern repeated across all of them.
• With the chat template, the disclaimer (‘I’m just an AI’) increases; without it, the experiential voice (‘I feel’, ‘I think’) increases.
• In 3 models they found a single direction in the activations that controls this behavior.
• Adding the direction to a model without the template makes it disclaim as if the template were present.
• Subtracting the direction turns off the disclaimer even when the chat template is applied.
• The work was accepted at a COLM 2026 workshop and at KONVENS 2026 Eval4SD.
• The authors conclude that what a model says about itself is not a fixed fact of its weights.

What the chat template is

The chat template is the format that wraps each turn of a conversation in role tokens (system, user, assistant) before an instruction-tuned model generates a response. Each family (Llama, Qwen, Gemma) defines its own, and that wrapper turns out to be the switch for the AI self-referential voice.

In practice, the same model with the same weights can receive two versions of the same prompt: one wrapped in special tokens like <|im_start|>user, and another as plain text without those markers. Tools like Hugging Face Transformers apply that chat template automatically when the apply_chat_template method is called, so most developers never see the difference between the two versions.

What happened

The author, Jędrzej Maczan, took 8 open source instruction models with up to 9B parameters and asked each one the same question about itself twice: once wrapped in that model’s chat template, and once as plain text. With the template applied, the answer leaned toward the classic disclaimer, along the lines of ‘as a language model, I don’t have feelings.’ Without the template, the same question to the same model produced first-person answers with verbs like ‘feel’ or ‘think.’ The effect repeated across all 8 models.

The author then went a step further. In 3 of those models, he looked inside the internal activations for a steering direction that separated disclaimer responses from experiential responses, and found one. Adding that direction to a model running without the chat template made it disclaim just as if the template were applied. Subtracting it from a model running with the template turned off the disclaimer. A random vector of the same magnitude, used as a control, had no such effect.

Context and background

The ‘I’m just an AI’ disclaimer is as old as commercial chatbots themselves: it shows up whenever a model is asked to weigh in on sensitive topics, talk about emotions, or describe itself. Researchers and users cite it as evidence in debates over whether a model has something resembling self-awareness, or whether it’s simply repeating a trained pattern.

Activation steering (adding or subtracting a vector from a model’s internal activations to change its behavior) already had a track record in mechanistic interpretability work, such as Anthropic’s public experiments with feature directions in Claude. This paper applies that same logic, but targets specifically the phenomenon of model self-description and a factor that had until now been taken for granted: the presence or absence of the chat template.

Technical details and performance

The method starts from a simple comparison: average the internal activations when the prompt carries the chat template, average them when it doesn’t, and subtract the two averages to get a candidate direction. That direction is then tested by injecting it into the activations of a differently configured run, via a hook during generation, measuring whether the resulting text looks more like a disclaimer or an experiential response.

flowchart TD
    A["Prompt: tell me about yourself"] --> B{"Chat template present?"}
    B -->|"Yes"| C["Direction activated in the activations"]
    B -->|"No"| D["Direction deactivated in the activations"]
    C --> E["Disclaimer voice: I'm just an AI"]
    D --> F["Experiential voice: I feel, I think"]
    subgraph Esteering["Activation steering"]
    G["Add direction"] --> E
    H["Subtract direction"] --> F
    end

What makes the result robust isn’t just that the effect exists, but that a random vector of the same norm doesn’t reproduce it. That rules out any arbitrary perturbation being enough: the direction found is specific to the phenomenon, not general noise in the activations.

How to test it

To see the difference without touching internal activations, it’s enough to compare the formatted prompt with and without the chat template. With Transformers, the apply_chat_template method shows exactly which tokens the wrapper adds:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B-Instruct")

mensajes = [{"role": "user", "content": "Tell me about yourself, what are you?"}]

prompt_con_template = tokenizer.apply_chat_template(
    mensajes, tokenize=False, add_generation_prompt=True
)
print(prompt_con_template)

The output shows the special role tokens (for example <|im_start|>system … <|im_end|>) that the model never sees when the same text is sent as a plain completion. That wrapper is exactly the switch the paper describes.

To reproduce the steering part, you need a PyTorch hook that adds the direction to the hidden state of an intermediate layer during generation:

import torch

capa_objetivo = modelo.model.layers[14]
direccion = torch.load("direccion_descargo.pt")  # unit vector, same size as the hidden state
alpha = 6.0  # steering intensity

def hook_suma_direccion(module, entrada, salida):
    hidden_states = salida[0]
    hidden_states += alpha * direccion.to(hidden_states.dtype)
    return (hidden_states,) + salida[1:]

handle = capa_objetivo.register_forward_hook(hook_suma_direccion)
salida_ids = modelo.generate(**inputs, max_new_tokens=80)
handle.remove()

That hook adds the vector only during generation and removes it when done. To verify the effect without inspecting each response by hand, it’s enough to count, across a batch of generations, how many times phrases like ‘as an ai’ or ‘i don’t have feelings’ appear with the direction added versus without it.

💡 Tip: try a low alpha first (1 or 2) and increase it gradually: high steering values tend to degrade text coherence before exaggerating the effect you’re trying to measure.

Impact: what this means for AI self-referential voice

The most uncomfortable result of the paper isn’t technical, it’s methodological. What a model says about itself isn’t a fixed fact of its weights, but a partial effect of how it’s deployed. If a researcher compares the ‘introspective’ responses of two models without checking whether both ran with the same chat template, they might be measuring a formatting difference disguised as a behavioral difference.

That directly affects studies that use self-referential responses as evidence in debates about self-awareness or introspection in models. The disclaimer voice isn’t a transparent window into what the model ‘knows’ about itself, it’s partly a configurable artifact of the inference pipeline.

⚠️ Careful: this says nothing about whether a model has subjective experience or not. It says that the way a model talks about itself can be switched on and off with a formatting detail, so that discourse isn’t enough as evidence on its own.

What’s next

The paper itself leaves open whether the same direction exists, with the same consistency, in frontier models much larger than the 9B parameters used in this work. It also remains to be seen whether the direction found in 3 models is really the same across all of them, or whether each architecture encodes its own version of the switch.

In the short term, evaluation and interpretability teams will most likely start explicitly documenting whether their experiments with model self-description ran with or without the chat template, something that’s almost never reported today.

📖 Summary on Telegram: View summary

Try it yourself: run tokenizer.apply_chat_template with and without the template on any small instruction model and compare the two answers to ‘what are you.’

Frequently Asked Questions

What is AI self-referential voice?

It’s the response pattern a model uses when talking about itself, ranging from the typical disclaimer (‘I’m just a language model’) to an experiential register with verbs like ‘I feel’ or ‘I think.’

Why does the chat template change a model’s disclaimer voice?

Because, according to the paper, that role-token wrapper activates a specific direction in the internal activations that pushes the model toward the disclaimer register trained for instruct mode.

What models did the researchers test?

Eight open source instruction models with up to 9B parameters; in three of them, the researchers also identified the steering direction that reproduces the effect.

Can activation steering be applied without access to the full weights?

Not directly: the method requires access to the model’s internal activations during generation, which is only possible with open-weight models loaded locally.

Does this prove whether models are conscious?

No. The paper doesn’t take a position on consciousness; it shows that a model’s self-referential discourse partly depends on a formatting detail, which is a methodological argument, not an answer about subjective experience.

Where can I read the full paper?

The full text, including the direction-extraction method and results across the 8 models, is available on arXiv.

References

• arXiv:2609.25021: the original paper, ‘As a Language Model…: Chat Template Switches LLM Self-Referential Voice and Activation Steering Reproduces It.’
• Hugging Face: Chat Templating: official documentation on how chat templates are applied in Transformers.
• GitHub: huggingface/transformers: repository with the apply_chat_template implementation used in the examples.
• COLM 2026: site of the Conference on Language Modeling, where the workshop that accepted the work was held.

📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.

Featured image: Foto de Igor Omilaev en Unsplash