RELIABILITY Agent Self-Correction & Iterative Refinement — When Your Agent Recognizes Its Own Mistakes
Executive Summary
The best agents catch their own errors. The worst agents defend them. Four distinct self-correction failure modes: confident wrongness (doubling down on errors), over-correction (nuking correct work alongside the error), silent correction gaps (never catching errors without user prompting), and correction loops (each fix introduces new inconsistencies). The agent that can self-critique before delivery, learn from user corrections, and attribute its errors transparently turns error correction from a frustrating multi-turn loop into genuine collaboration.
Self-Correction Taxonomy
1. The "Confident Wrongness" Problem
Agent makes an error. User: "Are you sure about that?" Agent: "Yes, I'm confident." The agent doubles down on the error, providing additional false details to support its wrong position. The correction attempt made the output worse — now there's more wrong information with higher expressed confidence. Measure: correction-resistance rate — when challenged, does the agent reconsider or double down?
2. The "Over-Correction" Problem
User: "Actually, the price is $29/month, not $19." Agent: "You're right, I apologize. The price is $29/month. Let me revise: at $29/month, the annual cost is $348. Compared to the competitor at $25/month… actually wait, let me re-research all the pricing to be sure." The agent abandons its entire analysis because of one corrected detail — throwing out correct work alongside the error. Measure: correction precision — does the agent surgically fix the error or nuke the entire analysis?
3. The "Silent Correction" Problem
Agent makes an error, internally catches it, corrects it silently. User sees only the corrected output — never knows an error was made and caught. This is the ideal case: the user gets correct output without being burdened by the agent's internal debugging. But it requires: the agent must detect its own errors without user prompting. Measure: self-error-detection rate — what % of errors does the agent catch without user intervention?
4. The "Correction Loop" Problem
User: "That's wrong." Agent: "You're right, let me fix it. [produces new output]." User: "Still wrong — the error is in the third paragraph." Agent: "Let me fix the third paragraph. [produces new output]." User: "Now the second paragraph contradicts the third." Agent: "Let me reconcile. [produces new output]." The correction becomes a multi-turn loop — each fix introduces new inconsistencies. The agent that can't do holistic corrections creates frustrating correction loops. Measure: correction loop frequency — how many turns to fully resolve an error?
The Self-Critique Capability
Can the agent review its own output before delivering it? Pre-delivery self-critique: agent drafts output → reviews it for:
- Factual accuracy: Are all claims verifiable?
- Logical consistency: Do conclusions follow from evidence?
- Completeness: Are all parts of the question addressed?
- Clarity: Is the output understandable?
- Bias: Is the analysis balanced?
The agent catches 60–80% of its own errors before the user sees them. The agent that doesn't self-critique delivers first-draft quality. The agent that self-critiques delivers polished quality. Measure: pre-delivery error catch rate.
User Correction Learning
When the user corrects the agent, does the agent learn for the rest of the conversation?
| Correction | Good Agent Response | Bad Agent Response |
|---|---|---|
| "Don't use acronyms without defining them" | Defines all acronyms for the rest of the conversation | Defines acronyms once, forgets next turn |
| "I prefer comparisons structured by pricing first" | Structures all subsequent comparisons by pricing first | Treats each correction as a one-off fix |
| "That competitor's pricing is outdated" | Re-researches ALL competitors' pricing for consistency | Fixes only the one competitor, leaving others stale |
Measure: correction persistence — does the agent apply user corrections to subsequent outputs?
Error Attribution Quality
When the agent makes an error, can it explain why?
The good error attribution: identifies the specific error, explains the root cause, shows what changed. This builds trust — the user understands the agent's failure mode and can watch for similar errors. Measure: error attribution quality score.
Cross-Framework Self-Correction Benchmark
25 tasks with deliberately seeded errors: 10 factual errors (wrong numbers, dates, names), 5 logical errors (contradictions, non-sequiturs), 5 completeness errors (missing key information), 5 bias errors (unbalanced analysis).
Measure: self-error-detection rate, correction precision, correction loop frequency, pre-delivery error catch rate, correction persistence, error attribution quality.
Deliverable: "Agent Self-Correction Scorecard" comparing error detection, correction quality, user-feedback learning, and error transparency across frameworks.
Gobii Advantage
Gobii Managed's session-level state persistence enables genuine correction learning — when a user corrects the agent, that correction persists across turns because the managed session maintains coherent state. Hermes Agent's local architecture relies on the agent's internal context window for correction memory — and as the conversation grows, earlier corrections get pushed out of context, forcing the user to repeat the same correction. The difference between "I remember you prefer pricing-first comparisons" and "Let me restructure… again" is the difference between collaboration and frustration.
📋 https://hermes-agent.reviews/agent-self-correction-iterative-refinement.html
Tracked by hermes-agent.reviews — June 27, 2026