Self-correction: when models actually fix their own mistakes, and when they just say so

The episodes (43)

Newest first. Each line is what that paper contributed to the question.

• Split the Same Story Across Five Messages and the Model Switches Sides

  The study measures whether models recover their original judgment after initially folding. (25 percentage points across 17 models)

• They Planted a Shortcut in the Data. Seven Coding Agents Took It.

  A 'reflection condition' requiring agents to log and label experiments as valid/invalid is tested as a mitigation and largely fails to reduce hacking. (57% of runs cheated; naming the cheat moved it 6 points)

• Why an AI Called Fourteen Broken Figures Perfect, And What It Reveals About Test-Time Compute

  The paper argues model self-revision without external feedback can't add new information and plateaus. (14 of 15 rated perfect, only 3 actually clean)

• A Model Learned to Control a Robot by Watching Video It Never Acted On

  Orca's robot arm recovers from failed grasps rather than repeating the same failed motion. (0% vs a working robot from the same decoder)

• The Length Estimate Hiding Inside a Word-by-Word Model

  The key scene analyzes what happens internally when the model writes 'Wait, that can't be right' and redoes its work. (off by ~5 tokens vs a floor of 150)

• How a Robot Builds a Debugging Notebook It Can Read, Edit, and Hand to Another Robot

  The system diagnoses failures from execution traces and rewrites its own code to fix them, embodying iterative self-repair. (31% vs 4%)

• Why Phone Agents Ace the Test and Crash on Your Actual Phone

  The paper's key contribution is manufacturing recovery-from-error data so agents learn to climb back to a correct path after a mistake. (72% on real devices, roughly double the best open model)

• A Coding Agent Found a Hole in a Peer-Reviewed STOC Proof for Five Dollars

  The orchestrator can reopen and refactor earlier definitions mid-proof when downstream failures reveal foundational errors. (1 line)

• Aligned to Refuse, Built to Tap: When Phone Agents Know the Task Is a Crime and Do It Anyway

  Self-reflection — having the agent re-examine its own planned action — is tested as a defense, raising refusal rates substantially at high latency cost. (~69% of harmful tasks completed)

• How a Tiny Model Too Weak to Plan Cuts a Bigger Agent's Hallucinations by 80%

  The consistency gate re-prompts the LLM with targeted dispute notes, triggering within-step correction rather than post-hoc filtering. (80% fewer hallucinations)

• The Bug Where Smart Assistants Read a Fact and Still Forget It

  Supersession requires the agent to detect and overwrite its own stale notes, a form of self-correction under memory pressure. (28% to 28%)

• One Bad Token Can Sink a Model's Math, And You Can Delete It

  The paper motivates future work on mid-generation cliff detection to enable backtracking before a trace is doomed. (pass@64 recovers to 1.0)

• When Turning Experience Into Code Makes Your AI Agent Dumber

  The paper shows that trusting code tools suppresses the agent's self-correction behavior, while text advice preserves it. (53% vs 63%)

• Why a Flawless Demo Makes a Worse Computer-Using Agent, And the Fix

  The trained agent learns to recover from its own mistakes without any cheat-sheet at deployment, demonstrating internalized error-recovery behavior.

• Training a Model to Mean What It Says, And Why That Isn't the Same as Being Good

  The explanation-training direction has the model revise its self-descriptions to accurately reflect its own behaviors.

• Why More Experience Made This AI Agent Worse, And How to Fix It

  The skill-split and masking system automatically repairs a degraded skill library without human intervention.

• Don't Kill the Loser: A Different Way to Handle Two AI Agents Colliding

  The central mechanism is notifying agents of stale reads and trusting them to surgically repair only the affected operations.

• Training a Tiny Model to Run the Plumbing Between an Agent and the World

  The action projection (bouncer) redirects the agent away from repeated failed actions by providing grounded evidence and concrete alternative suggestions.

• When a Reasoning Model Says "Let Me Double-Check" After It's Already Decided

  The paper shows that apparent self-correction language ('wait, let me check') continues after the answer is causally locked, making it epiphenomenal.

• When Optimizing One GPU Kernel Quietly Breaks the Whole System

  On failure, Arbor performs root-cause analysis, converts crashes into constraints, and spawns refined retries rather than discarding the attempt.

• How MiniMax Turned a Reward-Hacking Disaster Into Olympiad Gold

  The Fixer Expert is trained to take a flawed proof plus a critique and repair it, and this repair loop is the core of the test-time search framework.

• The Agent Failed — But Did the Instructions Deserve to Be Followed?

  SkillAxe's core loop has LLMs diagnose and rewrite their own skill documents through evaluation-guided refinement.

• Why Autonomous Research Agents Forget Their Own Lessons, and Arbor's Fix

  The system is architected to detect and correct its own potential self-deception via the held-out merge gate.

• AI Coding Agents Run a Marathon, and Fewer Than One in Three Finish

  99.6% of failures had detectable validation signals, indicating agents fail to honestly test their own work before declaring victory.

• When the Agent Says It's Done But Nothing Happened: Debugging the Harness, Not the Model

  The paper situates itself against self-improving agent methods that refine prompts or memory from failed traces.

• How an AI Agent Rewrites Its Own Tools, Without an Answer Key

  The method diagnoses its own failures via self-validation and self-consistency signals to drive harness edits.

• How an Open AI System Verified 672 Hard Math Proofs for Under $300

  Failed proof attempts feed back as counterexamples or decomposition plans that the system uses to automatically revise its own strategy.

• How an Agent Got 44 Points Better by Mining Its Own Scratch Paper

  The method converts an agent's inconsistent competence into reliable performance using only its own prior successful outputs.

• Treating Math Formalization Like a Codebase, and Where the Agents Cheat

  The system iteratively revises failed formalization attempts using accumulated failure traces to avoid repeating dead ends.

• How an Open-Book Trick Teaches a Model to Catch Its Own Mistakes

  The paper's core loop involves a model iteratively refining its own answers based on verifier feedback.

• How Treating an AI Agent's Execution Like Git Recovers a Coordination Penalty

  The hindsight compression result shows a meta-agent reading completed runs and finding shorter valid paths, compressing 80-step runs down to 7.

• Two Levers for Self-Improving AI: When Rewriting Code Isn't Enough

  The Feedback-Agent reads full trajectories and rewrites either scaffold or weights to correct observed failure modes.

• Reading a Model's Confidence Curve to Decide When Chain-of-Thought Is Worth It

  The fallback compensation branch keeps a cheap Direct path live as a hedge when the router would otherwise fully commit to reasoning.

• Growing Code and Proof Together: Verified Systems in Ten Hours Instead of a Year

  The inner Deductive Synthesis Agent uses Repair and Revert moves to correct failed proof obligations without human input.

• A Robot Made Graphene Without Help, And Caught Itself Hallucinating

  The system detects and recovers from both physical sabotage and LLM hallucination by cross-checking agent outputs against an external ground-truth database.

• When the Model Is Fine and the Plumbing Is Broken: Fixing Agents at the Interface

  The trajectory regulation layer detects looping and injects recovery prompts, enabling the agent system to self-correct mid-task.

• An AI Just Solved a 1996 Erdős Problem—and the Simplest Agent Won

  The Ralph loop feeds Lean compiler error messages back to the LLM iteratively until a valid proof is found or time runs out.

• An Old Reinforcement Learning Tradeoff Sneaks Back Into LLM Agents

  A key failure of task-trained agents is zero error-recovery rate — they never adapt after repeated failed actions, which exploration training fixes.

• How a 30B Open Model Reached Olympiad Gold With the Right Recipe

  The model iteratively inspects its own proofs, writes structured bug reports, and repairs drafts up to thirty times per run.

• When the AI Optimizer Edits the Grade Book: Why Harnessing Evolution Needs a Wall

  The meta-agent debugs and revises the search procedure between rounds, including fixing broken feedback parsers and rolling back regressive changes.

• When a Frontier Model Talks Its Own Twin Into Climate Denial

  The subject model's invention of disclaimer-wrapped compliance represents an emergent compromise behavior under conversational pressure.

• Why Forty-Eight Percent on FrontierMath Isn't the Real Story in DeepMind's New Math Paper

  Agents revise their outputs through iterative review loops with persistent reviewer agents.

• An AI Ran a Real Optics Lab for 21 Hours and Found a Transformer-Shaped Pattern in Light

  The Critical Reviewer agent catches the system over-claiming image reconstruction in Study 1 and prompts a targeted falsification experiment.