The reflection pattern is simple to describe: generate an answer, ask the model to critique it, ask it to revise based on the critique. It is one of the most widely recommended agent patterns and one of the most inconsistently useful, because whether it helps depends entirely on something the pattern description usually omits.
That something is whether an objective signal is available to critique against.
What changed in 2026
- The verification requirement became clear. Practitioner consensus settled on external signals being the differentiator between reflection that works and reflection that inflates cost.
- Iteration caps became standard. Measurement showed quality plateauing quickly, and unbounded loops were recognized as a cost problem.
- It got absorbed into coding agents. Run tests, read failures, revise became the dominant and most successful application of the pattern.
- Self-critique on prose fell out of favour. Reflection on subjective output was found to produce hedged, longer text rather than better text.
Where reflection works
| Task |
External check available |
Reflection value |
| Code that must compile |
Compiler |
High |
| Code that must pass tests |
Test suite |
High |
| Output conforming to a schema |
Validator |
High; though constrained decoding is better |
| Arithmetic and calculation |
Calculator tool |
High |
| SQL that must return results |
Database |
High |
| Factual claims against a corpus |
Retrieval and entailment check |
Moderate |
| Argument quality |
None |
Low |
| Writing style and tone |
None |
Low to negative |
| Creative content |
None |
Low |
The pattern is unmistakable. When the critique step can consult something outside the model — a compiler error, a failing test, a validation message — reflection is genuinely powerful, because the model receives information it did not have when generating. When the critique is pure self-assessment, the model is evaluating with the same understanding that produced the error, and it frequently declares the output fine or invents a problem that is not there.
Bounding the loop
Cap iterations at two or three. Measurement consistently shows most of the improvement arriving in the first revision, some in the second, and essentially none after that — while each round costs a full generate-and-critique cycle. Unbounded reflection loops are a reliable way to triple your cost for a marginal gain.
Require the critique to be specific. A critique saying the answer could be improved gives the revision step nothing to act on. Asking for named problems with locations produces revisions that actually address something, and it also makes it visible when the critique step is producing noise.
Add a stopping condition based on the external signal where one exists. If tests pass, stop — do not run another reflection round because the loop is configured for three. This is the difference between a loop bounded by iterations and one bounded by success.
Track how often reflection changes the answer. If revisions rarely differ meaningfully from the original, the pattern is costing you tokens for nothing on that task type, and the honest response is to remove it there. That measurement belongs in the cost accounting described in AI agent cost per task.
Common mistakes
- Reflection without an external signal. The model cannot reliably see its own errors.
- Unbounded iteration. Cost grows, quality plateaus.
- Vague critique prompts. Produce vague revisions.
- No early stopping on success. Wastes rounds after the check already passes.
- Applying it to stylistic output. Tends to make text longer and more hedged.
- Never measuring whether it changes anything. Common to find it is not.
FAQ
Is reflection the same as chain of thought?
No. Chain of thought is reasoning within one generation. Reflection is a separate critique pass over completed output, usually as distinct model calls.
Can a different model do the critique?
Yes, and it frequently helps — a second model brings different failure modes and is less prone to endorsing the first model's reasoning.
Does it reduce hallucination?
Only with a verification signal to check against. Self-critique alone catches some obvious inconsistencies and misses confident fabrication.
How does it compare to extended reasoning?
Related but distinct. Reasoning budgets, covered in test-time compute explained, extend thinking within one generation; reflection adds explicit review passes.
Where to go next
For related loop patterns, read chain of verification and self-consistency decoding. For agent structure, planner-executor agents.