--- title: "A Prompt Formatting Trick Boosts LLM Self-Correction Rates by 93 Points" subtitle: "A new paper proves LLMs refuse to correct their own mistakes not because they can't, but because of how chat templates label the source of a claim ā€” and a zero-training fix exists." url: "https://alphasignal.ai/news/a-prompt-formatting-trick-boosts-llm-self-correction-rates-by-93-points" author: "AlphaSignal Newsroom" author_url: "https://alphasignal.ai/editorial-team" company: "AlphaSignal" company_url: "https://alphasignal.ai/company/alphasignal" published: "2026-06-04T00:00:00.000Z" updated: "2026-06-12T01:32:36.320Z" type: "Paper" topics: - "Reasoning" - "Llms" subtopics: - "Hallucinations" - "Structured Output" upvotes: 850 source_url: "https://arxiv.org/abs/2606.05976" comments: 0 truncated: true --- # A Prompt Formatting Trick Boosts LLM Self-Correction Rates by 93 Points > A new paper proves LLMs refuse to correct their own mistakes not because they can't, but because of how chat templates label the source of a claim ā€” and a zero-training fix exists. LLMs are increasingly trusted to run autonomously in multi-step pipelines, catching and fixing their own errors as they go. There's just one problem: they are remarkably bad at it. A new [paper from researchers at National Cheng Kung University](https://arxiv.org/abs/2606.05976) argues this is not a reasoning failure at all. It is a formatting bug baked into how modern chat templates work , and it can be fixed with a single structural change to your prompt, no retraining required. ## The problem everyone assumed was cognitive When an LLM makes a mistake inside its own chain-of-thought, asking it to "audit your reasoning" rarely works. The model will often re-derive the correct final answer silently, but never explicitly call out the wrong intermediate step. Meanwhile, if you show the same model the exact same wrong claim attributed to an external source , a user, a tool, or a memory block , it will catch and reject it almost immediately. Recent work shows that LLM agents struggle to correct errors in their own reasoning traces yet show markedly higher correction rates when identical claims appear under external sources. The central question is whether this asymmetry reflects a capability deficit or a role-label artifact: does an agent's willingness to correct a wrong claim depend causally on the chat-template role that carries it, rather than on the claim's content? The industry has largely treated this as a cognitive limitation, motivating expensive fixes: external verifiers, multi-agent critique loops, and training-time interventions. This paper argues the real culprit is far more mundane. ![Architecture diagram showing correction-rate lift across four role types: thought, user, tool, and memory](https://arxiv.org/html/2606.05976v1/x1.png) ## What chat templates actually do to your model Every modern instruction-tuned LLM processes conversations through a **chat template** , a structured format that wraps each message in role labels like `system`, `user`, `assistant`, or `tool`. These aren't just cosmetic labels. During instruction tuning, models are trained to respond differently depending on which role a message comes from. The system role outranks the user role, which outranks the tool role, and so on. Because agent-to-agent and agent-to-tool messages typically flow without human inspection, the harness is precisely where systematic effects can hide in plain sight. Chat-template role labels carry behavioral weight that exceeds their literal text content. The model's own `` block, it turns out, sits at the bottom of this hierarchy , treated as something the model produced, not something it should critically engage with. The key insight: when an LLM agent encounters an erroneous claim, its willingness to correct that claim depends primarily on the chat-template role label attached to the claim, rather than on the content of the claim itself. ## The experiment: byte-identical, role-swapped To test this cleanly, the researchers designed an experiment with a crucial guarantee: the wrong claim (`cā˜…`) is kept **byte-identical** across every condition, verified with SHA-256 hashing. The only thing that changes is the chat-template role wrapping it. Five conditions were compared: _Preview only. Full text requires an AlphaSignal Pro account._ ## Sources - [The Self-Correction Illusion: LLMs Correct Others but Not Themselves](https://arxiv.org/abs/2606.05976) - [The Self-Correction Illusion ā€” Full Paper HTML](https://arxiv.org/html/2606.05976) - [Large Language Models Cannot Self-Correct Reasoning Yet (Huang et al., 2024)](https://arxiv.org/abs/2310.01798) - [The Instruction Hierarchy: Training LLMs to Prioritize Privileged Instructions (Wallace et al., 2024)](https://arxiv.org/abs/2404.13208) - [ChatInject: Abusing Chat Templates for Prompt Injection in LLM Agents (ICLR 2026)](https://en.papernotes.org/ICLR2026/llm_agent/chatinject_abusing_chat_templates_for_prompt_injection_in_llm_agents/)