Flashcard: how is self-correction different from self-refine in agents?

Flashcard·Easy·4.0 · 0·~30s·Asked atArize Ai Baidu Canva·Relevant atAnthropic

Attempt it

Self-correction is an agent detecting mid-run that a step it just took produced a wrong or unexpected result and trying a different approach in the same task, typically by re-reading the Observation, revising the plan, or calling a different tool. It happens inside the agent loop, between turns, using external evidence to trigger the correction. Self-refine (Madaan et al. 2023, arXiv 2303.17651) is a tighter loop: the model critiques and rewrites its own draft answer in the same turn, with no external observations involved. The agent generates an answer, then prompts itself to critique it, then prompts itself to revise based on the critique. Self-correction is grounded in real tool results; self-refine is grounded only in the model's own self-judgement. Self-correction lives in agent runtimes (ReAct, LangGraph); self-refine lives in single-turn prompting pipelines. Both are forms of in-context error recovery without weight updates.

Your answer

**Self-correction** is what an agent does when it notices, mid-run, that something just went wrong and changes its approach. The signal usually comes from an external Observation: a tool returned an error, a test failed, a search returned no results, an API response was unexpected. The agent re-reads the Observation, revises its plan, and tries a different tool or a different argument on the next turn. **Self-refine** is different. It is a single-turn pattern. The model generates an initial draft of its answer, then prompts itself to critique that draft, then prompts itself to rewrite based on the critique. All three steps happen in one task before any external action is taken. There are no Observations involved. The core distinction is the source of the error signal. Self-correction uses real evidence from the outside world. Self-refine uses the model's own opinion of its draft. Both are useful. Self-correction is the standard mechanism for handling tool failures and surprise results in agent loops. Self-refine is the standard mechanism for tightening up answers in single-turn pipelines where no tools are involved.

**Self-correction** is an agent detecting mid-run that a step produced a wrong or unexpected result, and trying a different approach in the same task. It happens between turns of an agent loop. The triggering signal is an external Observation: a tool error, a test failure, a search miss, a parser rejection. The agent re-reads the Observation, revises its plan, and emits a different Action on the next turn. **Self-refine** (Madaan et al. 2023, arXiv 2303.17651) is a tighter pattern that lives inside a single turn. The model generates a draft answer, prompts itself to critique the draft, then prompts itself to revise based on the critique. The whole loop runs without any external observations or tool calls. The improvement comes from the model judging its own output. The load-bearing distinction is the signal source. Self-correction is grounded in real-world feedback. Self-refine is grounded only in the model's self-judgement. Both are in-context error-recovery patterns with no weight updates, but they apply at different layers of the stack. In practice, agents combine them. A coding agent might run self-refine inside one turn to tighten a code edit before submitting it, then run self-correction across turns when the test runner fails. The two patterns compose cleanly because they operate at different levels: self-refine is intra-turn, self-correction is inter-turn.

TL;DR

Self-correction is an agent revising course mid-run based on real Observations. Self-refine is the model critiquing and rewriting its own draft answer in one turn with no external evidence.

Memory aid

Easy to grasp

Imagine writing an essay. Self-refine is writing a draft, reading it over, deciding it could be better, and rewriting it before showing it to anyone. You judged your own work and revised. Self-correction is more like writing one paragraph, showing it to a friend, hearing them say 'wait, you got that fact wrong', and then revising the next paragraph based on their feedback. The first relies on your own opinion; the second relies on real feedback from the outside world. Both make the answer better, but they use different signals to know what needs fixing. Agents use both: self-refine inside one turn, self-correction across turns when a tool returns a result the agent did not expect.

Key concepts

Self-correction Self-refine Critique Error Recovery

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Self-correction and self-refine are both in-context error-recovery patterns: ways for an LLM to improve an answer without any weight updates. They are easy to conflate because both involve the model fixing its own mistakes. The load-bearing difference is the source of the error signal. Self-correction is triggered by external evidence; self-refine is triggered by the model's own self-judgement.

This distinction shows up everywhere in interview questions about agent design, and the two patterns are routinely treated as interchangeable when they are not. Mixing them up signals fuzziness on what makes an agent loop reliable in production.

This explanation walks through what each pattern looks like in practice, why the signal source is the structural distinction, the known limit of self-refine, how the two compose in production agents, and how frontier reasoning-mode models absorb both into hidden reasoning loops.

Self-correction: an agent revising course mid-run

Self-correction is what happens when an agent reads an Observation and realises its previous Action was wrong or the situation changed. The trigger is always external: a tool returned an error, a unit test failed, a search returned zero results, an API response was malformed, a parser rejected the output.

The correction happens between turns of the agent loop. After a failed Observation, the model's next Thought reads the failure and reasons about what to do differently. The next Action then takes a different approach: a different tool, different arguments, a smaller scope, a fallback strategy.

For self-correction to work, the runtime has to surface tool failures as readable Observations rather than silently retrying or crashing. A well-built agent runtime catches exceptions, formats the error as a string Observation ('Tool fetch_url failed: 404 Not Found'), and feeds it back into the loop. The model can then read the error and reason about it.

Self-correction is the dominant reason ReAct-style agent loops outperform open-loop chain-of-thought on multi-step tasks. The closed loop bounds error propagation precisely because each Observation gives the agent a chance to correct course. Without self-correction, the agent would compound errors instead of recovering from them.

Self-refine: critique then revise in one turn

Why the signal source is the structural distinction

The known limit of self-refine

How they compose and where they live in 2026

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Cursor and Cline coding agents run self-refine inside one turn to tighten a code edit, then self-correction across turns when the test runner fails or the language server reports an error.
Anthropic claude-code uses self-correction when a tool call fails, reading the error in the next Observation and choosing a different tool or argument.

What an interviewer would ask next. Try answering before peeking at the approach.

QWhy does self-refine fail on certain reasoning tasks that self-correction handles fine?

Self-refine's critic is the same model as the generator. On tasks where the model is wrong, the critic is also wrong; it approves bad answers and rejects good ones. Self-correction uses external evidence (tool results, tests) that does not share the model's blind spots, so it can correct errors the model itself cannot recognise.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Treating self-correction and self-refine as the same pattern under different names. The signal source is different: external Observations versus the model's own self-judgement.

60 second bullets to scan on the way to the call.

Define self-correction as agent course-correction triggered by an external Observation.
Define self-refine as a single-turn draft, critique, revise loop with no external observations.

Primary sources. Browse if you want the original framing.