Why Large Language Models Fail to Correct Their Mistakes

1,847 concepts1,019 papers15 proposals

A common intuition in machine learning is that if a model is capable of generating a solution, it should also be capable of critiquing and refining it. This concept of "intrinsic self-correction" underpins many iterative prompting strategies. However, empirical evidence across comprehensive benchmarks—such as the one introduced by Yin et al. in MMAU: A Holistic Benchmark of Agent Capabilities Across Diverse Domains—reveals a persistent bottleneck: without external feedback or specialized training, large language models (LLMs) frequently fail to autonomously correct their own mistakes, often degrading their initial performance instead.

To understand why self-correction fails, we must look under the hood at the fundamental mechanics of autoregressive generation, training data distributions, and the cognitive asymmetry between finding and fixing errors.

The Localization Gap: Finding vs. Fixing

Why does a model fail to fix a mistake when prompted with a generic instruction to "review your answer"? The core issue is often not an inability to generate the correct logic, but an inability to locate where the logic initially diverged.

In LLMs cannot find reasoning errors, but can correct them given the error location, Tyen et al. decoupled the task of error localization from error correction. They discovered a stark asymmetry: while LLMs are remarkably proficient at fixing reasoning errors when provided with the exact location of the mistake, they are exceptionally poor at identifying those errors themselves.

Without an external signal to pinpoint the flaw, unguided self-correction becomes a guessing game. As Chen et al. observe in MAgICoRe: Multi-Agent, Iterative, Coarse-to-Fine Refinement for Reasoning, models struggle to isolate specific faulty steps within their own multi-step reasoning chains. Similarly, Lai et al. emphasize in Step-DPO: Step-wise Preference Optimization for Long-chain Reasoning of LLMs that identifying the precise transition point where a reasoning path becomes invalid remains a primary bottleneck. When a model cannot localize its error, a request to self-correct often causes it to alter perfectly valid steps instead, leading to a net decrease in accuracy.

Autoregressive Inertia and the Snowballing Effect

The second major reason self-correction fails lies in the mechanics of autoregressive generation. LLMs generate text token-by-token, conditioning each new token on all previously generated text. This design introduces a form of "cognitive inertia."

When a model makes an early logical error, those incorrect tokens enter its context window and are subsequently treated as established facts. Lin et al. demonstrate this failure mode in ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning, noting that standard language models lack an inherent mechanism for internal backtracking when they encounter a logical contradiction. Instead of recognizing the contradiction and rewinding the generation to an earlier state, the model continues generating text conditioned on the mistake.

This behavior leads directly to what Muru Zhang terms the "snowballing" effect in How Language Model Hallucinations Can Snowball. Rather than self-correcting, the model generates false justifications to maintain consistency with its own previous errors, even when it "knows" those justifications are factually incorrect in isolation. As Wang et al. point out in INTERVENOR: Prompting the Coding Ability of Large Language Models with the Interactive Chain of Repair, models remain anchored to their original logic, making autonomous debugging exceptionally difficult without an external perspective or environmental signal.

[Initial Prompt] ──> [Valid Step 1] ──> [Flawed Step 2] ──> [Step 3: Conditioned on Flaw]
                                                                   │
                                                                   ▼
[Self-Correction Prompt] <─────────────────────────────────────────┘
  │
  ├──> Autoregressive Inertia: Model treats Flawed Step 2 as ground truth context.
  └──> Snowballing Effect: Model generates false justifications to maintain consistency.

The Asymmetry of Gold-Standard Training Data

Why haven't language models naturally developed the ability to backtrack or diagnose their own errors? The answer lies in the distribution of their training data.

Standard pre-training and fine-tuning datasets consist almost exclusively of "gold-standard," error-free text. As Muru Zhang highlights, this complete absence of recovery examples prevents models from learning how to navigate and rectify mistakes mid-generation. Because models are rarely exposed to trajectories that involve making an error, diagnosing it, and pivoting to a new strategy, they lack the causal understanding required for self-correction.

An et al. confirm this empirically in Can LLMs Learn From Mistakes? An Empirical Study on Reasoning Tasks, showing that models are significantly worse at correcting their own mistakes than they are at correcting the mistakes of weaker models. Furthermore, Wan et al. argue in Failure Makes the Agent Stronger: Enhancing Accuracy through Structured Reflection for Reliable Tool Interactions that error diagnosis is not a native capability; without explicit training on error-correction trajectories, models cannot transform abstract diagnostic reasoning into actionable adjustments.

The Internal Bias Loop

Finally, self-correction often fails because of an "internal bias loop." When a model critiques its own output, it uses the same underlying parameters and logical frameworks that produced the error in the first place.

As Yang et al. explain in SuperCorrect: Advancing Small LLM Reasoning with Thought Template Distillation and Self-Correction, a model's internal evaluation is prone to the exact same logical flaws present in its initial reasoning. If a model lacks the conceptual mastery required to solve a problem, its self-critique will suffer from the same blind spots. This limitation is echoed by Yan et al. in Large Language Models Facilitate the Generation of Electronic Health Record Phenotyping Algorithms, who note that iterative prompting yields minimal gains when a task requires a logical framework the model has not mastered.

Even when a model experiences what Ding et al. describe as an "aha moment" in Sherlock: Self-Correcting Reasoning in Vision-Language Models, a massive gap remains between recognizing that a mistake occurred and successfully rerouting the reasoning chain to arrive at the correct conclusion. Recognizing a failure does not inherently trigger a valid corrective trajectory.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 892 papers
  2. Version 1 · 2026-10-04 · 1181 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_self_correction_failure_b6f84981,
  title = {self-correction failure},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/self-correction-failure/rdr_b6f84981b8604e7198a0ff9bd3129efc},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 2, frozen text):

@misc{lacuna_self_correction_failure_b6f84981_v2,
  title = {self-correction failure},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/self-correction-failure/rdr_b6f84981b8604e7198a0ff9bd3129efc/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake