# What is Reflection Pattern?

Also called self-critique loop, critic pattern.

The reflection pattern is an agent design in which a first pass output is fed back for explicit criticism, and the criticism is then used to produce a revised output. The critique may come from the same model in a separate call, a different model, or an automated check such as a compiler, test suite, or validator.

Reflection works because generating and evaluating are different tasks. A model producing text under one framing may miss problems that become visible when it is asked directly to find faults. Separating the two into distinct calls, each with its own instructions, tends to surface issues that a single generate and hope pass leaves in place.

The quality of reflection depends almost entirely on the critique signal. Grounded signals, meaning a failing test, a schema validation error, a linter, or a retrieved source document, produce reliable improvement because they are external facts. Ungrounded self-critique, where a model judges its own prose with no external reference, improves style and completeness more reliably than it improves factual accuracy.

Published results on self-correction are mixed and this is worth stating plainly. Several studies have found that models asked to revise without external feedback can degrade correct answers as often as they fix wrong ones, particularly on reasoning tasks. Reflection is therefore most defensible where a checkable signal exists.

Loops need limits. Each reflection round costs another call and adds latency, and revisions often converge or begin oscillating between two versions after two or three rounds. Implementations cap the number of rounds and stop early when the critique reports no material issues or when the external check passes.

## Key points

- Separates generation from an explicit critique step
- External signals like tests beat ungrounded self-judgment
- Evidence for unaided self-correction is mixed
- Rounds are capped, since revisions converge quickly
- Adds latency and cost proportional to rounds

## In practice

A code writing agent produces a function, then runs the project's test suite. Two tests fail, and the failure output plus the offending source is passed back as the critique. The revised function passes, and the loop exits after one round. The same agent given no test suite would have to judge its own code, a far weaker signal that stops short of proving anything.

## Related terms

- [Agent Loop](/en/glossary/agent-loop)
- [Chain of Thought](/en/glossary/chain-of-thought)
- [Self-Consistency](/en/glossary/self-consistency)
- [Agent Trajectory](/en/glossary/agent-trajectory)
- [ReAct Pattern](/en/glossary/react-pattern)

[Back to the AI Glossary](/en/glossary)