How AI Agents Evaluate Their Own Outputs and Implement Self-Correction Loops

Every agent vendor promises self-improvement. The research says something much less flattering: left to grade its own homework, GPT-4 didn't get smarter — it got worse. Self-correction only works when the verdict comes from something the model didn't author.

A self-correction loop sounds like magic: the agent writes, judges, revises, repeats until it's right. The catch is the judge. A weak evaluation sets a hard ceiling on the whole loop, and the same model that made the error is the worst possible person to spot it. The evidence on this is unusually blunt — and it should change how you build agents.

The verdict the hype skips

Grading your own homework backfires. Huang and colleagues (ICLR 2024) tested intrinsic self-correction — no oracle, no external tool — and found it fails to improve reasoning and frequently makes it worse. On GSM8K math, GPT-4 fell from 95.5% to 91.5% after one self-correction round, and 89.0% after two — while burning five model calls instead of one. The loop was more likely to fix a correct answer into a wrong one than to repair an actual error.
The "success stories" cheated. Several studies that reported glowing self-correction results quietly used an oracle stopping rule: stop as soon as the answer is correct. That leaks the ground truth into the procedure. With the oracle, GPT-4 on GSM8K jumped to 97.5%; with the model deciding for itself when to stop, the gains evaporated or inverted. If a benchmark's self-correction numbers look too good, check who decides when to stop.
Four ways to judge, and only some are honest. Self-critique shares the generator's blind spots. Rule-based checks (schemas, unit tests) are deterministic but only prove what they test. Tool-grounded verification — run the code, query the database, search the claim — gets its verdict from the real world. External judges (a second model, a reward model, a human) sit outside the generator entirely. Anthropic's evaluator-optimizer workflow is the cleanest version of the last pattern.
The patterns that actually work anchor on evidence. Reflexion works when the feedback is real — a test failure, a compiler error. CRITIC's verify-then-correct loop checks claims against search engines and code interpreters, and removing the tools sharply drops its effectiveness. Self-consistency gains come from aggregating many sampled paths, not from any guarantee the samples are independent.
The honest exception. Self-Refine — one model as generator, feedback provider, and refiner, with no external signal at all — reported ~20% average improvement across seven tasks. Intrinsic self-correction isn't always doomed; it's task- and training-dependent. Which is exactly why you can't assume it works for your task.

Build it like this, or don't build it

Deterministic checks first. Schema validation, format checks, unit tests, database lookups — cheap, fast, and they give the loop verdicts that mean exactly what they say. Add an LLM critic only for judgments no rule can express.
Make the critique structured. A free-form paragraph of praise and complaint is useless to the next generation pass. A verdict plus a list of defects, each with evidence and a concrete fix, is directly actionable.
Let the tool speak first. A code-generation loop that runs the code, reads the traceback, and feeds the traceback to the critic beats a critic guessing at what might be wrong. In LangGraph, that's a generate node, a critique node, and a conditional edge — with ToolNode error handling returning the failure as a message instead of crashing the graph.
Cap it hard. Three iterations max in practice — every round multiplies tokens and latency, and a five-round loop that produces a slightly worse answer is worse than no loop at all. Log every iteration so oscillation and drift are inspectable, and escalate to a human when the loop can't converge. Escalation isn't a failure of the design; it is the design.

The practical conclusion is narrower than the hype and more useful than the scepticism: build the loop around the strongest verdict you can get, cap the iterations, log everything, and measure whether it helps for your specific task and model — including checking for regressions. Neither external provenance nor the recommended safeguards guarantees success.