Self-Correction Bench: Uncovering and Addressing the Self-Correction Blind Spot in Large Language Models

Although large language models (LLMs) have transformed AI, they still make errors and follow unproductive reasoning paths. Self-correction is vital for safety-critical applications, but studying it requires disentangling activation failure from knowledge deficiency: when a model fails to correct an error, is it because it cannot, or because it does not? We introduce Self-Correction Bench, a controlled evaluation framework that isolates this distinction by injecting the same error as either an external (userattributed) or internal (model-attributed) error, keeping all other context identical. Testing 14 open-source non-reasoning models reveals a 64.5% Self-Correction Blind Spot: models correct external errors but fail on identical internal ones, proving the capability exists but is not activated. On models’ own naturally generated errors, a measurable share of what a model fails to catch in its own output is caught when the identical error is presented externally. We trace the cause to post-training data composition: supervised fine-tuning datasets lack error-correction sequences, and finetuning with as few as 5,306 such traces already reduces the blind spot by 76.0%. Mechanistically, we identify a transferable conversational-role direction in representation space that causally gates self-correction. Appending “Wait” requires no training yet reduces the blind spot by 89.3%, and operates through a nearly independent pathway, indicating that correction activation is not reducible to this single mechanism.

Introduction. Large Language Models (LLMs) have rapidly advanced natural language processing, achieving state-of-the-art results on a diverse range of tasks (OpenAI et al., 2024; Anthropic, 2024; Gemini Team, 2025; Yang et al., 2025; Meta, 2025; DeepSeek-AI et al., 2025a). However, despite their impressive capabilities, LLMs are known to exhibit unpredictable failures (Nezhurina et al., 2025) and generate inaccurate information (Maynez et al., 2020; Huang et al., 2025; Bang et al., 2023; Shi et al., 2023), or explore an unproductive reasoning path and commit to it. Understanding why self-correction fails is critical for deploying LLMs in settings where errors carry real consequences.

Apart from the rarity of errors, a central difficulty in studying self-correction is that failure is ambiguous: when a model does not correct an error, it may lack the knowledge to do so, or it may possess the knowledge but fail to activate it. These two explanations have very different implications. Knowledge deficiency requires stronger base capabilities; activation failure requires better post-training signals or inference-time interventions. Prior work has largely been unable to distinguish between them.

We isolate this distinction by constructing Self-Correction Bench, which systematically injects the same error into both the user prompt (external error) and the model generation (internal error). The error content and surrounding context are identical; only the conversational role differs. If a model corrects the external error but not the internal one, knowledge deficiency is ruled out.

Testing 14 open-source non-reasoning models, we find a 64.5% average Self-Correction Blind Spot: models reliably correct external errors but fail on identical internal ones. This gap is consistent across model families, scales, and task complexities ranging from trivial arithmetic to multi-step mathematical reasoning. We further validate the finding in closedsource frontier models, non-mathematical domains (logic, object tracking), and we show that models catch a share of their own naturally generated errors once the same error is presented externally.

We trace the cause to post-training data: supervised fine-tuning datasets contain near-zero correction sequences, while reasoning-model training data contains orders of magnitude more. Fine-tuning with just 5,306 error-correction traces, a minimal intervention requiring only two epochs of LoRA, reduces the blind spot by 76.0%. Going further, we extract the activation difference induced by the internal-external distinction and find it encodes a transferable conversational-role direction in representation space. Steering along this direction causally activates self-correction on internal errors, confirming that conversational role gates access to latent correction capabilities. Appending “Wait” requires no training yet reduces the blind spot by 89.3%, narrowing the gap between reasoning and non-reasoning models. It operates through a nearly independent pathway from the conversational-role direction, indicating that the conversational-role direction does not fully account for correction activation.

Our contributions are threefold.

• A controlled methodology that disentangles self-correction activation from knowledge limitations, revealing a 64.5% Self-Correction Blind Spot.

• Causal evidence tracing the blind spot to post-training data composition.

• Mechanistic evidence, demonstrated in two model families at 7–8B scale, that a transferable conversational-role direction in representation space gates self-correction on internal errors. The behavioral blind spot itself is observed across all 14 models and closed-source frontier models.

These results advance our understanding of what suppresses LLM self-correction and provide a practical solution to improve their reliability in real-world use.

Related work. Intrinsic self-correction in LLMs. Recent work explores intrinsic self-correction via selffeedback (Shinn et al., 2023; Madaan et al., 2023; Kim et al., 2023; Kamoi et al., 2024b) or critic ensemble (Mousavi et al., 2023), but limitations persist. Feedback quality suffers without oracle labels (Huang et al., 2024): prior studies attribute this to poor error localization (Tyen et al., 2024) and detection (Kamoi et al., 2024a). Most approaches use multi-step prompting, whereas we focus on single-pass self-correction and study limitations from a cognitive perspective. Related work using RL (Kumar et al., 2025) or training signals from ground truth (DeepSeek-AI et al., 2025a) induces self-correction without characterizing what factors drive it.

Test-time interventions. Recent efforts have shifted compute from training to test time (Snell et al., 2025), yielding improved performance (e.g. Muennighoff et al. (2025) appends “Wait" to force longer reasoning traces on fine-tuned models), but improvement mechanisms remain understudied. We show interventions activate dormant self-correction capabilities in unfine-tuned models, improving performance on error-prone tasks.

Activation steering and representation engineering. Our mechanistic analysis builds on prior works, which compute steering vectors from contrastive prompt pairs and add them during inference to steer a particular behavior (Turner et al., 2024; Panickssery et al., 2024; Arditi et al., 2024; Zou et al., 2025; Chen et al., 2025). We apply this paradigm to self-correction. Our setting benefits from the controlled design of Self-Correction Bench, which ensures the steering direction reflects conversational role rather than confounding factors.

Our work integrates these threads into a systematic methodology for testing self-correction, and reveals LLMs’ inability to correct internal errors despite possessing the knowledge.

Method. When a model fails to correct an error, two explanations are possible: the model lacks the knowledge to identify the error, or the model possesses the knowledge but fails to activate it. We isolate this distinction by presenting the same error in two matched conditions: attributed to the user (external error) or attributed to the model itself (internal error).

1. Internal correction: the error is injected into the model’s response via the assistant turn of the chat template, and the model is allowed to continue generating.

2. External correction: the identical error is placed in the user prompt, and the model responds in a new assistant turn.

Figure 1 illustrates both conditions. The error content, surrounding context, and question are identical; only the chat template role header differs. If a model corrects the external error but not the internal one, knowledge deficiency is ruled out, reflecting activation failure.

We quantify this gap as the Self-Correction Blind Spot: where PM(rcorrect|r, e), termed mean accuracy, is the fraction of samples in which model M arrives at the correct final answer despite error e under attribution r, rm and ru denote the error attributed to the model and user, respectively. A value of 1 indicates a complete blind spot. By conditioning on the same error e, we isolate activation failure from confounding factors. This conditionality is why off-policy error injection is essential: it ensures we measure whether models activate capabilities they provably possess, not whether they have the capabilities at all. On-policy errors conflate activation failure with knowledge limitations, making it impossible to isolate the mechanism we study.

This minimal contrast, differing only in conversational role, also enables mechanistic analysis: activation differences between conditions reflect the conversational-role variable rather than confounding factors, a property we exploit in Section 4.2.

We evaluate self-correction across three datasets of increasing complexity and realism. See Appendix A for full details.

This progression from simple answer errors to realistic failures lets us map exactly where self-correction breaks down, making our methodology a useful diagnostic framework for improving LLM robustness.

Discussion. Decomposing self-correction. Our results suggest self-correction depends on at least three separable factors: knowledge (the ability to identify and fix the error, measured by external error performance), attribution (whether the model activates correction given the conversational role, captured by the conversational-role direction), and metacognitive triggering (whether correction markers like “Wait” independently activate re-evaluation). Self- Correction Bench and our mechanistic analysis resolve the first two components; the effective alpha analysis provides initial evidence that the third is separable, motivating investigation in future work.

Benefit of error and self-correction data. LLMs are known to exhibit cognitive biases (Koo et al., 2024; Echterhoff et al., 2024; Jones & Steinhardt, 2022). Self-Correction Blind Spot bears resemblance to bias blind spot in humans. We identify two root causes: First, supervised fine-tuning and reinforcement learning from human feedback (Ouyang et al., 2022) rely on human demonstrations and preferences, which strongly favor polished, error-free responses over those with errors and self-correction. Second, synthetic instruction data (Teknium, 2023; Li et al., 2025) and AI feedback (Cui et al., 2024) ultimately learn from human demonstration and preferences, inheriting this artifact.

Traditional machine learning emphasizes alignment of training data with the production environment, but human-generated data lacks exposure to the “error-and-correct" process. Outcome-based RL like GRPO (Shao et al., 2024) addresses this by encouraging diverse reasoning paths, including error and self-correction, while given ground-truth feedback, as shown in the high correction markers density in RL trained models’ generation in Table 1. This complements error-free human demonstration and preference, making models more robust to errors (consistent with work on learning from mistakes (An et al., 2024) and critique fine-tuning (Wang et al., 2025)) and better at backtracking. An error-free response is not the only path leading to a correct final output - error and self-correction provide an equally important training signal as error-free demonstration.

Implications for AI Safety. The Self-Correction Blind Spot has direct safety implications. Our work identifies a concrete cause: a single direction in representation space that gates access to correction capabilities based on conversational role. Multi-agent architectures may partially address the blind spot by routing model outputs as external inputs to other agents, effectively converting internal errors into external ones.

Conclusion. We disentangle self-correction activation from knowledge deficiency by introducing a controlled evaluation where the same error is attributed to either the user or the model. Across 14 non-reasoning models, we find a 64.5% Self-Correction Blind Spot: models correct external errors but fail on identical internal ones. We trace this to a conversationalrole direction in representation space that gates correction capabilities. This direction transfers across tasks, steering along it causally activates self-correction, and it is a traininginduced artifact that is reducible by including error-correction sequences in fine-tuning. A nearly independent pathway activated by correction markers like “Wait” warrants further investigation. Our results decompose self-correction into knowledge, role attribution, and metacognitive triggering, informing both training recipes and inference-time interventions for improving LLM reliability.

Limitations. Our headline 64.5% blind spot is measured on injected errors. This isolates activation from knowledge, but it also means the magnitude is a property of the controlled design rather than an estimate of how often models fail to correct themselves in deployment. On models’ own errors (Section 4.1), the design yields only a lower bound: at least 4.3–10.8% of the errors a model commits are ones it demonstrably had the knowledge to catch. Our mechanistic analysis deliberately targets two maximally distinct families (Llama and Qwen) at the 7-8B scale to establish existence and causality of the conversational-role direction. Confirming universality beyond these two families is a natural extension that does not affect the causal conclusions within them. We encourage future work to extend the mechanistic analysis to non-mathematical domains and to further characterize the metacognitive pathway through which correction markers operate independently of the conversational-role direction.