Skip to main content
Back

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.

Paper, Full Access
  • LLMs fail to correct their own reasoning errors not due to a cognitive gap, but because of how chat-template role labels signal trust and addressability.
  • Wrapping a byte-identical wrong claim in an external role (<memory>, user, or tool) lifts explicit correction rates by 23–93 percentage points across 7 model families.
  • The fix requires zero training or model modification — just restructure the prompt to re-present the wrong intermediate under an external role before the audit instruction.
  • Best role is domain-dependent: <memory> works best for math; plain user works best for logical deduction.
  • Reasoning-tuned models (DeepSeek-R1, GPT-4.1) are already at ceiling and don't benefit; the intervention targets vanilla instruction-tuned models.
  • The adversarial mirror is asymmetric: injecting errors via external roles fails by default (<3.3% attack rate), but a single trust-framing sentence collapses this safety to 70%. Paper

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 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

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 <thought> 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: