Does it actually make answers more accurate?

It makes them better formed. Whether it makes them truer is a different question, because those are different faults. A second read finds a dropped requirement, a missing section or the wrong shape, since all of those are visible in the text it is reading. A fact the first pass never had is visible nowhere, so the check has nothing to catch it with.

How many passes are worth running?

Almost always one, and the reason is that the first pass does nearly all of the work available to it. A second changes less and a third less again, and beyond that the text drifts away from an answer that was already correct. Running more is one of the commoner ways to turn a good result into a worse one.

A whole extra request, charged and waited for, on every item that goes through it. That is why it tends to be applied selectively rather than everywhere: the places where a malformed answer is expensive earn the second pass, and the places where it is merely untidy usually do not. Cost is the reason it is a choice.

Glossary

Reflection

Reflection is a second pass in which a system checks and revises its own answer before you see it, which catches some kinds of mistake and adds a step to every request.

In plain terms

Asking it to read its own answer back before handing it over. It looks for what it got wrong, then writes the answer out again, which tidies a great deal for very little effort. What it will not do is notice something it simply did not know, because the one checking knows exactly what the one writing knew. The gap is invisible from inside.

Why it matters

Because it is the cheapest quality improvement available. It is also the easiest to overrate. A second pass reliably tidies structure, catches a dropped requirement and fixes a shape that was asked for and not delivered, so the output looks markedly better for very little work. What it does not do is supply knowledge the first pass lacked, which is exactly where the confident wrong answers live.

How it works

The second pass is a separate request rather than a cleverer first one. The system is shown its own output and asked to find fault with it, then to produce a revision, so the work happens twice and is charged twice. That structure is why the improvement is real and why the cost is not marginal, though some systems now fold a version of it inside a single pass.

It is much stronger on form than on fact, because those two failures have different causes. A dropped condition, a missing section or an answer in the wrong shape are all visible in the text itself, so a careful second read finds them. Something the first pass did not know is visible nowhere in the output, and the one checking knows precisely as much as the one writing did.

Returns fall away quickly after a single pass, which surprises teams expecting a dial they can turn. A second revision changes less than the first and a third changes less again, and past that the text starts drifting away from an answer that was already correct. Repeated passes are where a good result quietly becomes a worse one.

It sits badly under anything that must hold every time, and that is the part worth saying plainly. A pass which usually catches a missing requirement is not a guarantee that the requirement is there, so anything that genuinely must hold belongs in a check outside the request rather than in one more look at it.

What a second look finds, and what it cannot

The reason this distinction gets lost is that both columns produce the same reassuring sentence in a status update, so a team hearing that output is checked has no way to tell which column was meant. It matters because the two failures carry very different costs. A malformed answer is caught downstream by whatever consumes it, and usually loudly, so the second pass is buying tidiness and saved rework. An answer that is fluent and untrue passes every structural check there is, travels onward looking exactly like a good one, and is found much later by somebody who trusted it. A process that leans on self-checking for the second kind has bought confidence rather than accuracy, and the useful question to put to any such arrangement is which column it was tested against. Ask that first.

Seen in the wild

An assistant asked to review its own draft against the brief before that draft is handed on, which is this same second pass run by hand.
Claude
A framework where a critique step and a revision step are separate nodes in a graph, so the second pass is explicit and can be inspected.
LangChain / LangGraph
A canvas where a checking operation is its own node after the one that produced the text, so every record in a batch gets the same second look.
Gumloop

Common misconceptions

People assume

It catches the answer being wrong.

In fact

It catches the answer being malformed far more reliably, because a fault visible in the text is a fault a second read can find. A statement that is simply untrue looks exactly like a statement that is true, and the pass brings no knowledge to the page that the first one did not already have.

People assume

Telling them apart

Reflection vs LLM as judge

Reflection

It checks its own answer, inside the same run.

LLM as judge

One system scores another's output, as a measurement.

The mechanism is the same and the subject is not, so checking your own work improves this answer while scoring somebody else's produces a number you can track.

Questions

Does it actually make answers more accurate?: It makes them better formed. Whether it makes them truer is a different question, because those are different faults. A second read finds a dropped requirement, a missing section or the wrong shape, since all of those are visible in the text it is reading. A fact the first pass never had is visible nowhere, so the check has nothing to catch it with.
How many passes are worth running?: Almost always one, and the reason is that the first pass does nearly all of the work available to it. A second changes less and a third less again, and beyond that the text drifts away from an answer that was already correct. Running more is one of the commoner ways to turn a good result into a worse one.
What does it cost?: A whole extra request, charged and waited for, on every item that goes through it. That is why it tends to be applied selectively rather than everywhere: the places where a malformed answer is expensive earn the second pass, and the places where it is merely untidy usually do not. Cost is the reason it is a choice.

Key takeaways

The second pass is its own request, so the work is done twice and charged twice.
Much stronger on form than on fact, because the checker knows what the writer knew.
Returns collapse after one pass, and repeated passes drift away from a right answer.
Anything that must hold every time needs a check outside the request, not another look.

Tools that use this

Claude
Reviewing its own draft against the brief before that draft goes on.
LangChain / LangGraph
Critique and revision as separate, inspectable nodes in a graph.
Gumloop
A checking node after the producing node, applied across a batch.