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

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.

Quick reference

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

Sign in for the mnemonic that makes this stick. See Pro pricing.

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

Detailed answer & concept explanation

~6 min read

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

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

Sign in for 5 free unlocks/day or go Pro for unlimited. See Pro pricing.

Quick scan · 2–4 min

Everything important, quickly.

Define both patterns with the signal-source distinction. Self-correction uses external Observations between turns; self-refine uses self-judgement within one turn. Attribute self-refine to Madaan et al. 2023. Name the known limit: pure self-judgement degrades on tasks where the critic is no better than the generator. Close with how the two compose in production and how frontier reasoning-mode models absorb both.

Real-world examples

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.
Frontier reasoning models (OpenAI o3, Claude Opus 4.7 extended-thinking, Gemini 3.1 deep-think) generate hidden self-critiques during their reasoning phase, applying self-refine internally before emitting the visible answer.
LangGraph's reflexive-loop pattern adds a critic node after each generator node, executing self-refine within a state-graph workflow before the next external action.

Interviewer follow-ups

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?

Sign in or go Pro to see the approach for this follow-up.

QHow does a production agent compose self-refine and self-correction together?

Sign in or go Pro to see the approach for this follow-up.

QWhat happens to these patterns in frontier reasoning-mode models?

Sign in or go Pro to see the approach for this follow-up.

Don't say this

Red flags and common mistakes 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.

Sign in or go Pro to see all red flags and common mistakes. See Pro pricing.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

Sign in for 5 unlocks/day or go Pro for unlimited revision sheets. See Pro pricing.

References

Primary sources. Skim if you want the original framing.