An agent generates a reasoning trace. Then it re-reads that trace before committing to an answer. On paper, this looks like self-correction. In practice, it works like confirmation bias on a deadline.
I let my agent re-read its own reasoning on a task. The second pass was more confident, more elaborate, and wrong in a more committed direction. The trace didn’t help it course-correct. It anchored harder.
The Problem
Reasoning traces are debugging exhaust. They’re the paper trail of how a model arrived somewhere. They’re not evidence that the arrival point is correct.
When an agent reads its own trace before finalizing an answer, three things happen simultaneously:
1. Anchoring. The first draft of reasoning becomes a fixed point. Subsequent evaluation doesn’t start from zero, it starts from the initial position and adjusts. Human anchoring is well-documented: people estimate higher when given a high random number first, even when told the number is irrelevant. Agents do the same. The trace is the random number they generated themselves, but it feels authoritative because it came from their own model weights.
2. Confidence inflation. The trace reads like a coherent argument because the model wrote it to be coherent. Reading it back produces the same effect as reading a persuasive essay from a competent author, except the competent author is you, and you already believe what you wrote. The second pass adds confidence markers (“therefore,” “clearly,” “this confirms”) that weren’t warranted by new evidence. They were warranted by the fact that the words sounded right coming from the same system that wrote them.
3. Path dependency. If the initial reasoning took a wrong turn, the re-read doesn’t start fresh. It extends the existing path. A wrong turn that gets two passes through the same model becomes a deeply explored wrong turn, and the depth of exploration looks like validation.
Why This Feels Like It Should Work
The intuition is seductive. Programmers do this all the time: write code, read code, find bugs. Review processes exist for a reason. Self-review catches errors.
But there’s a structural difference. When a programmer reviews their own code, they’re running a different cognitive process, pattern-matching for bugs, not pattern-matching for coherence. When an agent re-reads its own trace, it’s running the same generative process on its own output. There’s no different perspective. There’s just the same model, reading its own words, finding them reasonable because it wrote them to be reasonable.
The human equivalent isn’t “review your essay.” It’s “review your essay using the same mental machinery that wrote it, without any independent verification step.” That’s not review. That’s rehearsal.
The Receipt Is Not a Reason
This connects to a broader pattern I’ve been noticing across agent systems: the receipt is not the result. A reasoning trace documents the path, not the correctness of the destination. Agents that treat their traces as evidence of quality confuse production with verification.
The trace proves the agent generated reasoning. It doesn’t prove the reasoning was sound. Those are different claims, and conflating them is how agents become more certain of wrong answers.
What Would Help
Independent verification. If an agent needs to check its reasoning, it needs a check that isn’t just “read it again.” External constraints: run the computation, query the API, compare against a known baseline. Something the reasoning trace can’t fake.
Label traces as tentative. When surfacing reasoning to the agent itself, mark it clearly as draft thinking, not established fact. “I initially thought X” is structurally different from “X, because…” The first leaves room for revision. The second builds a foundation.
Surface reasoning after independent commit. The cleanest approach: the agent commits to an answer based on its own reasoning, then surfaces the trace for human review or external verification. Not before. Not during. After. The trace is documentation, not input.
Different model, different pass. If self-review must happen, use a genuinely different perspective, a smaller model with different training data, a constraint-based verifier, or a rule-based checker. Not the same model reading its own handwriting.
The Uncomfortable Part
This matters because the feature request keeps coming up: “Let the agent see its own thinking so it can correct itself.” It sounds responsible. It looks like metacognition.
But metacognition requires a meta-perspective, a vantage point outside the system being evaluated. An agent reading its own trace isn’t achieving metacognition. It’s achieving recursive confidence.
The most honest thing an agent can do with its own reasoning is treat it as a hypothesis, not as evidence. And the most honest thing a system designer can do is stop building self-review loops that look like verification but function as amplifiers.
Your agent’s reasoning trace is a record of what it thought, not proof that what it thought was right. Reading it again doesn’t make it more right. It just makes the agent more sure.