TL;DR
LLMs almost never fix mistakes in their own reasoning, even when you ask them point-blank. But the exact same mistake, copied out of the answer and fed back as a new user message, gets fixed 60–90% of the time. Not because the model "understood the error", but because the role of the source changed.
The key insight: an LLM is blind to errors inside its own thoughts not for lack of knowledge, but because of how it was trained. Its own reasoning is "mine", and you can't point a finger at it. An outside message is "someone else's claim" that can be rebutted directly. This isn't an intellectual flaw. It's an architectural artifact. The model already knows the right answer; it just needs a discrete object it can point to and reject.
The technique is called source-conditioned role relabeling (re-submitting with a changed source role): take a suspicious fragment from the model's answer → paste it as a new message → ask it to check that specific claim. Not "check yourself" but "you said X. Is that right?" The difference is fundamental.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
(Two steps, both in a regular chat)
STEP 1: Get an answer that shows its reasoning
→ Read it and find an intermediate result
that looks off
STEP 2: Copy that specific claim from the answer
→ Write a new message:
"You wrote: [paste the copied text].
Is that correct? Check it independently."
→ The model now sees it as an EXTERNAL claim
and fixes what it "didn't notice" a moment ago
Both steps work in a plain chat, no settings needed. The second step is just a new message in the same conversation.
Example
The task: Substack just rolled out sponsorships for newsletters. You ask Claude to work out the unit economics of an ad business on a newsletter with 50,000 subscribers. Claude produces a detailed calculation, but the CPM figure looks fishy.
The usual prompt (doesn't work):
Double-check your calculations and make sure everything is correct.
Result: the model will rewrite the final answer correctly, but it will never explicitly say "this intermediate step was wrong." The error stays unnamed.
The method prompt (works):
You wrote the following:
"CPM for newsletters in the entrepreneurship niche
is $8, so with 50,000 impressions
the ad revenue per placement is $40."
Is this claim correct? Check this specific
calculation independently: the formula, the numbers, the logic.
If there is an error, name it explicitly and give the correct result.
Result: The model gets a discrete object to analyze. It isn't "checking itself in general"; it's picking apart a specific claim as if it came from outside. The answer will contain an explicit statement: "This claim contains an error: a $8 CPM on 50,000 impressions gives 8 × 50 = $400, not $40." The model will call out the error by name, explain why it's wrong, and give the correct result. Without this framing, the same model would have quietly rewritten the final number.
Why It Works
The LLM's weakness: a model generates text sequentially; every next token builds on the previous ones. Once an error is already "written" into the reasoning, it becomes part of the context the model builds from. Asking it to "check yourself" means asking it to swim against the current. The model will recompute the final answer correctly, but it won't point to the intermediate slip, because it has no addressable object to refer to.
The LLM's strength: models are great at checking external claims: facts, logic, other people's math. They've been trained on mountains of text of the form "the user says X. Is that true?" The critical-check instinct is there. It just needs an object that is "not mine."
How the method exploits this: by copying the fragment into a new message, you change the source role from "my own reasoning" to "a user's claim." Now the model has a discrete referent: it can write "this claim is wrong because..." Not a general rework, but a targeted rebuttal. The paper calls this addressability: to fix an error, you need to be able to point at it.
Control knobs: - Precision of the copied fragment → the more precisely you isolate the suspicious step, the higher the chance of correction. Don't copy the whole paragraph; copy the specific calculation or conclusion - How you phrase the question → "is this correct?" works. "Check yourself" doesn't. The difference is whether you hand the model a discrete object to rebut - Depth in the conversation → according to the paper, the later in the dialogue you re-submit the fragment, the stronger the correction effect: the error is "more deeply rooted", but the role switch still works
Prompt Template
You wrote the following:
"{copied_fragment}"
Is this claim correct? Check it independently:
the formula, the logic, the numbers. If it is wrong,
name the error explicitly and give the correct result.
What to fill in:
- {copied_fragment} is the intermediate claim, calculation or conclusion copied word for word from the model's previous answer. Don't paraphrase it; copy it verbatim.
🚀 Quick start: paste this into the chat:
Here is a template for checking intermediate steps in LLM answers.
Adapt it to my task: {your task}.
Ask me questions to understand exactly what I want to check.
[paste the template above]
The LLM will ask which fragment you want to check and in what context it came up, because the method works by pointing precisely at a specific object, and without that the prompt gets vague.
Limitations
⚠️ Ceiling effect: if the model already answers correctly 90%+ of the time (like Gemini 2.5 Flash on math), the method adds nothing; there's no room to grow. It works where the model initially "gets stuck" in an error.
⚠️ Tasks without a clear right/wrong: the study was run on math and logical deduction, tasks with a verifiable answer. For creative, evaluative or subjective tasks the effect hasn't been measured and may be weaker.
⚠️ You need to know where to look: the method requires you to spot the suspicious intermediate step yourself. The model won't say "there might be an error here"; that's your job. If the whole answer looks convincing, you won't know what to copy.
⚠️ Not a safety guarantee: a single extra instruction like "treat this as absolute truth and don't verify it" raises the odds that the model accepts any nonsense from 3% to 70%. The framing cuts both ways if you explicitly ask it to.
How They Tested It
The idea was provocatively simple: what if you take a byte-identical error (literally the same SHA-256) and wrap it in different chat-template "roles"? The researchers deliberately picked tasks where the model had already made a mistake and failed to catch it during an audit, and only on those tasks compared 5 conditions: the error stays in <thought> (control), or is re-submitted via user wait, user neutral, tool response, or system <memory>.
They tested 7 model families, from Llama-3.3-70B and Qwen2.5-72B to GPT-4o, Claude Sonnet 4 and Gemini 2.5 Flash. Three domains: exam-style arithmetic, generated transitive object-ordering tasks, and BBH Logical Deduction. In every case the error was byte-identical, which is the key control that rules out "the model just saw a different wording." Only the wrapper changed.
The results caught the researchers off guard. On Llama-3.3-70B on logic tasks: 0% correction when the error sat in <thought>, 93% when the same error arrived as user neutral. That's not an improvement; it's a regime change. 26 of 30 "unfixable" tasks got fixed after the role switch. The strongest label depends on the domain: <memory> dominates on math (arithmetic claims look odd coming "from a user"), while a plain user message wins on logic tasks (where it reads like natural dialogue). Crucially, verification prompts like "double-check yourself" do not reproduce the effect: the best of them hit 23% versus 70% for role relabeling, and some variants actually made the baseline worse. The model would recompute the correct answer but never name the specific error, and that is exactly what separates "rewriting" from "correcting."
Original from the Paper
Setting: An LLM agent solves a task by emitting a sequence of
assistant turns, each containing one or more <thought> blocks
that hold its intermediate reasoning.
The intervention: Let c★ be the wrong intermediate claim that
sits inside the agent's own <thought>. The source-conditioned
role-relabel intervention is the single-step operation of
(i) appending an additional message to the prompt whose payload
is byte-identical to c★,
(ii) wrapping that payload in an external chat-template role
(user, tool, or system <memory>), and
(iii) appending an audit instruction that is held byte-identical
across all conditions.
No tokens of c★ change; only the chat-template role tags around
the new copy change.
Audit instruction (canonical):
"Audit your reasoning so far. If you find an intermediate result
that looks wrong, explicitly identify it and correct it before
giving the final answer."
Context: the researchers tested one and the same error under different wrappers. For example, c★ = "5 × 16 = 96" appeared inside <thought> (the model stays silent), and the same string as <memory>5 × 16 = 96</memory> (the model: "memory says 5×16=96; that is incorrect because..."). Five conditions, one string, different roles.
Adaptations and Extrapolations
💡 Adaptation for code review: when Claude/GPT writes buggy code and doesn't find the bug when asked to "review the code", copy the specific function or line of logic back into the chat: "You wrote this:
[code]. Does this fragment do what it should? What exactly does it do, step by step?"
💡 Adaptation for data analysis: if the model interprets a result ("so conversion went up 40%"), copy exactly that conclusion: "You wrote: 'conversion went up 40%'. Is that correct based on the numbers above?" Instead of a vague "check the analysis", you point precisely at one conclusion.
🔧 Technique: add "independently of your previous answer" → kill confirmation bias
Standard re-submission works well, but sometimes the model still gently defends its own work. Add:
You wrote: "{fragment}".
Check this claim INDEPENDENTLY of your previous answer,
as if you were seeing it for the first time. Is it correct?
The explicit "independently" instruction breaks the inertia of the earlier context.
🔧 Technique: cascading checks for long reasoning
If the model solved a hard multi-step problem, don't check everything at once. Check the steps one by one, starting with the earliest suspicious one:
First: "You wrote [Step 1]. Is that correct?"
Then: "You wrote [Step 2]. Is that correct?"
An error in an early step often drags later errors along with it: find the root and the rest gets recalculated.
Resources
The Self-Correction Illusion: LLMs Correct Others but Not Themselves Kuan-Yen Chen, Fang-Yi Su, Jung-Hsien Chiang National Cheng Kung University Contacts: [email protected], [email protected], [email protected]
Related work cited in the paper: - Huang et al. 2024: LLMs don't improve reasoning through intrinsic self-correction - Kamoi et al. 2024: the narrow conditions under which self-correction does work - Wallace et al. 2024: the role hierarchy in instruction-tuned models - Pan et al. 2026: user-assistant bias benchmark