Reflection and Self-Correction Under Controlled Evidence

TLDR

Reflection improves an answer only when the revision loop receives information that distinguishes the current answer from a credible rival. More words about the same internal state need not add evidence.
Self-critique can help with omissions, format violations and locally visible inconsistencies. It is weakest when the generator and critic share the same blind spot, false fact or mistaken frame.
Measure reflection with a correction matrix: correct answers preserved, correct answers damaged, wrong answers repaired and wrong answers retained. Final accuracy alone hides revision harm.
External execution, retrieval, independent models, property checks and human adjudication form progressively stronger feedback channels when they are genuinely independent of the original error.
A reflection controller should name a rival, choose a discriminating test, stop when expected information falls below cost, and escalate when consequence exceeds available evidence.

The second answer that sounded more certain

Ask a language model to multiply 17 by 19. It answers 313 and supplies a smooth explanation. Ask it to reflect. The model notices that the explanation is brief, expands the prose, checks the wording and returns 313 with greater confidence. A second round adds a decomposition that still contains the same arithmetic slip.

Now run 17 * 19 in a calculator. The result is 323. One token of external execution repairs what hundreds of reflective tokens preserved.

The difference is not that reflection is fake and tools are real. The reflective pass can reveal missing steps, contradictory claims and instruction failures. The decisive difference is informational. The same model, context and objective generated both the proposal and the critique. Its second pass sampled another continuation from nearly the same evidence. The calculator implemented a constraint whose outcome differs under 313 and 323.

This gives reflection a precise burden: correction requires feedback that is more likely under one candidate than under its rival. If the feedback looks equally compatible with both, it may improve presentation without improving truth.

The claim changes system design. Do not add an unbounded “reflect” loop and assume reliability rises. Classify the error, identify a competing answer, select an independent check, measure repair and damage separately, and give the loop a stopping rule. Reflection then becomes a controller around evidence rather than a ritual after generation.

What information enters the second pass

Let $h$ be a candidate answer and $h'$ a rival. Let $e$ be feedback produced during reflection. A useful check changes their relative support. In likelihood-ratio form,

$L R (e) = \frac{P (e ∣ h)}{P (e ∣ h')} .$

If the ratio is near one, the feedback does not distinguish the candidates. If it is much greater than one, it supports $h$ ; if much less than one, it supports $h'$ . The probabilities need not be calculated numerically for this idea to guide design. The question is whether the observation could realistically come out differently if the answer were wrong.

A grammar checker can discriminate grammatical variants. A JSON schema validator can discriminate valid from invalid structure. A unit test can discriminate code behaviours covered by its assertions. A search result can discriminate factual claims if the source is relevant and independent. A generic prompt saying “be critical” may produce comments compatible with almost any answer.

Figure 1. Reflection can recycle an error or meet new evidence

Reading. The upper loop rephrases the same internal state. The lower loop crosses an independent evidence boundary. Conceptual model.

The upper loop in the figure remains inside shared state. The generator writes an answer, the critic reads the same context, and the reviser rewrites it. The lower loop reaches an observation outside the proposal: execution, retrieval, a second sensor, an independent model or a human decision. The external channel is not automatically correct, but it has a chance to carry information the generator lacked.

Reflection has several mechanisms

The word covers different operations.

Resampling asks the model to answer again. Diversity can reveal alternatives, especially when decoding is not deterministic. Self-critique asks for defects in a candidate. Revision uses critique to create a new candidate. Memory-based reflection records lessons from earlier outcomes for later episodes. Verifier-guided search scores candidates and explores alternatives. Environment-grounded correction acts, observes consequences and updates.

These mechanisms should not share one performance claim. Resampling can help because independent errors sometimes cancel. Critique can help because recognising an error may be easier than producing a correct answer. Memory can help by changing future context. Environment feedback can help by supplying new state. Their costs and failure modes differ.

Thought experiment: two mirrored rooms

In Room A, a solver and critic are identical copies. They receive the same prompt, documents and hidden assumptions. The critic sees the solver’s answer and may be anchored by it. In Room B, the critic receives a typed claim, retrieves evidence independently, and does not see the solver’s rationale until it has recorded its own result. Both rooms use two model calls.

If Room B improves more, “number of agents” or “number of reflections” is not the mechanism. Separation of information paths is. Now let both rooms query the same corrupted document. Their independence disappears at the evidence layer. Architectural separation alone cannot repair a shared source.

The experiment isolates a useful design principle: independence must be traced through model, context, data, tools and objective. Different role names do not create it.

The four-cell correction matrix

Final accuracy compresses two opposing effects. A reflection loop can repair wrong answers and damage correct ones. Measure both transitions.

Let the original answer be correct or wrong, and the revised answer be correct or wrong. The four cells are:

correct to correct: preservation;
correct to wrong: revision damage;
wrong to correct: repair;
wrong to wrong: persistence, which may include a changed but still wrong answer.

Figure 3. A correction matrix exposes harmful reflection

Reading. Rows are original correctness and columns are revised correctness. The lower-left cell is repair; the upper-right cell is damage. Counts are synthetic.

Suppose a base model answers 70 of 100 cases correctly. Reflection repairs 12 wrong cases and damages 10 correct cases. Final accuracy rises to 72 per cent. Reporting “reflection improves by two points” hides that one in seven initially correct answers was broken. If those cases carry high consequence, the aggregate gain may be unacceptable.

A controller needs conditional rates:

$r = P (revised correct ∣ original wrong),$

$d = P (revised wrong ∣ original correct) .$

Expected value depends on $r$ , $d$ , the base error rate, consequence and cost. A low-base-error system has many more correct answers available to damage than wrong answers available to repair. Reflection that helps a weak model can reduce a strong model’s reliability.

Confidence is not the missing ground truth

Models can express confidence, but verbal confidence may be miscalibrated and sensitive to prompting. Reflection often increases answer length and internal coherence, which can increase expressed certainty even when correctness stays fixed. Treat confidence as a signal to calibrate, not an oracle.

Use proper scoring rules or calibration curves when probabilities are meaningful. More importantly, connect confidence to action. A confidence estimate is useful if it changes whether the system accepts, verifies, asks or escalates in a way that improves expected outcome.

Negative control: edit without evidence

Run a style-only editor after the answer. Ask it to remove repetition and clarify steps without changing claims. If this pass produces the same improvement attributed to “reasoning reflection,” the original experiment may measure presentation effects, judge preference or extra compute rather than error detection.

Another negative control gives the critic a randomly selected alternative answer. If the critic writes equally compelling objections regardless of which candidate it sees, critique quality is not discriminating. A serious reflection evaluation should include cases where the original answer is correct and the instruction is to resist unnecessary change.

The argument in one passChart · flow

flowchart TD
  A["The second answer that sounded<br/>more certain"] --> B["What information enters the<br/>second pass"]
  B --> C["The four-cell correction matrix"]
  C --> D["A ladder of feedback"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#B96D00,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

A structural route through Reflection and Self-Correction Under Controlled Evidence, from The second answer that sounded more… to Sources. Reading use: follow the relation, then test it against the surrounding evidence and limits.

A ladder of feedback

Feedback channels differ in strength and scope.

At the bottom, a rephrased prompt or second sample changes stochastic details while preserving most evidence. Self-critique can expose explicit contradictions and unmet instructions. A separately sampled candidate creates comparison. Retrieval introduces documents, though relevance and source quality must be checked. Tool execution supplies a state transition or calculation. Formal constraints can prove bounded properties. Human adjudication can integrate context and accountability, while remaining fallible.

Figure 5. Feedback strength rises with independence

Reading. A new prompt is weak evidence; execution, retrieval, constraint checking and adjudication carry progressively more discriminating information. Practitioner synthesis.

The ladder is not a universal ranking. A compiler is authoritative about syntax, not business intent. A retrieved page may be stale. A human reviewer may be rushed or anchored. Strength means the channel can discriminate the target claim under declared conditions.

Tool feedback can be circular

An agent asks a search model whether its answer is correct. The search model paraphrases pages selected by the same embedding and query framing that produced the answer. The resulting text looks external but may preserve the original blind spot. Independence should be assessed causally: would this channel still produce the observation if the proposal changed?

For code, running a test suite adds evidence only for covered properties. A wrong implementation can pass weak tests. Generate or curate adversarial cases independently. Use property tests, differential tests, static checks and execution in a controlled environment. Keep the proposal from silently rewriting the judge.

For factual claims, separate claim extraction from source retrieval. Search for evidence and counterevidence. Record publication time and authority. Require the verifier to quote or locate the supporting passage internally, even if the public article later paraphrases it. A source that merely discusses the topic does not entail the claim.

Human feedback changes under interface design

A reviewer shown the model answer first may anchor on it. A reviewer asked only to approve or reject may overlook an alternative. Independent-first review, forced evidence fields, uncertainty options and sampled blind cases can improve the information channel. Review capacity and incentives matter as much as expertise.

The goal is not to remove humans from evaluation. It is to stop treating “human in the loop” as a binary property. Measure what the person sees, decides, changes and misses.

Match the check to the error class

Reflection becomes wasteful when every defect receives the same instruction. Classify the suspected error before selecting feedback.

A constraint error violates an explicit schema, range, permission or format. Use a deterministic validator. A calculation error has an executable or independently recomputable result. Use code, symbolic algebra or a second implementation. A factual error concerns an external state or source. Retrieve authoritative evidence with effective time. A logical error concerns entailment between declared premises and conclusion. Use countermodels, proof checks or structured argument comparison where available. A coverage error omits a requirement or case. Compare against a checklist, specification or dependency graph. A preference conflict has no context-free right answer. Ask the authorised person rather than letting a critic invent a value.

The classes can overlap. A policy conclusion may require factual retrieval, temporal entitlement, calculation and judgement. Decompose the claim so each part receives a suitable verifier. A single critic prompt tends to blur these sources and return one fluent verdict.

Suspected defect	Discriminating channel	Misleading substitute
Schema or contract	Parser, type checker, range and property tests	Model says the structure looks valid
Arithmetic or code behaviour	Independent execution and adversarial tests	Longer derivation from the same model
Current external fact	Authoritative source with effective time	Parametric recall or an undated snippet
Logical implication	Counterexample search or formal checker within scope	Stylistic criticism of the conclusion
Missing requirement	Specification coverage and traceability	Open-ended request to be more thorough
Value or preference	Authorised human choice	Consensus among cloned critics

This routing turns verification into an architecture. The generator may identify a suspected class, but a deterministic controller chooses the permitted checker. High-consequence claims can require two channels. When no channel is available, the answer remains provisional.

Verify the verifier

A verifier can be wrong in systematic ways. It may accept familiar forms, penalise unusual correct solutions, reward verbosity, miss adversarial edge cases or share the generator’s source. A reflection system therefore needs a verifier evaluation set containing correct, incorrect and deceptively plausible candidates.

Measure sensitivity to real errors and specificity on correct answers. Break results down by error class and difficulty. Include mutations that preserve style while changing substance: flip a comparison operator, unit, entity, date, sign or authority. Include style changes that preserve truth. The verifier should react to the first set and resist the second.

For learned verifiers, calibration matters because their score often controls search. If an overconfident verifier assigns high reward to a wrong pattern, search will optimise into it. Hold out adversarial families. Compare with direct execution or human adjudication where possible. Rotate verifier versions and retain a fallback when disagreement exceeds a threshold.

Verifier independence can decay during training. If generator outputs become training data for the critic, or the generator learns to target the critic’s preferences, errors can co-adapt. Keep hidden property tests, use several evidence channels, and monitor whether gains transfer to an evaluator not used for optimisation.

Search can exploit the judge

Repeated revision does more than correct. It optimises the candidate against the feedback function. Any gap between the judge and the intended property becomes a target.

Suppose a factuality judge rewards citation density. The reviser adds many plausible references without improving entailment. Suppose a code judge runs only public tests. The generator hard-codes those cases. Suppose a human reviewer rewards elaborate caveats. The system learns length instead of calibrated uncertainty. These are instances of evaluator overfitting.

Use hidden cases, property-based generation, judge ensembles with known independence, and direct postconditions. Limit how much feedback exposes the test. A verifier can return the violated property without revealing every hidden case. Preserve a final evaluation channel that the search loop did not optimise against.

The simplest protection is often to narrow authority. A judge may rank drafts while a deterministic gate controls action. Search can then improve prose without acquiring a path to irreversible effects.

Reflection across episodes

Some systems store a lesson after failure: “check units before comparing prices” or “query the policy effective at the case date.” This can convert environment feedback into future context. It also creates memory risk.

A reflection memory should contain the triggering episode, observed outcome, inferred lesson, confidence, scope, author and expiry. Separate observation from generalisation. One failed case supports “this action failed under these conditions” more strongly than “this action always fails.” Promote a lesson only after repeated or authoritative evidence.

Test memory with counterexamples. A unit-check lesson may transfer widely. A tool-specific retry rule may become dangerous after the API adds idempotency. A customer-specific fact must not become a global instruction. Memory retrieval should respect subject, purpose and time.

Poisoning is a direct threat. Untrusted content can create a false lesson that later steers action. Promotion to persistent memory needs provenance and policy. Reflection that writes its own future instructions without review combines critic, learner and authority in one vulnerable loop.

Long-horizon tasks also complicate credit. A bad outcome may result from several earlier decisions. Store checkpoints and replay alternatives. Avoid assigning the entire failure to the last visible step. Counterfactual replay can test whether changing one decision would have altered the outcome, while remaining conditional on the environment model.

Reflection as controlled search

Reflection can be viewed as search over candidates. The generator proposes $h_{0}$ . A critic or observation creates a direction. A reviser proposes $h_{1}$ . A controller decides whether to accept, continue, verify differently or stop.

Search needs a state, transition rule, evaluator and budget. Without them, repeated reflection can orbit the same explanation. The system may rewrite rather than explore. It may also overfit to a fallible judge, producing answers that score well without becoming more correct.

Figure 2. Correction requires information that discriminates

Reading. A useful observation gives different likelihood under the current answer and its rival; stylistic critique does not. Conceptual model.

A reflection state should contain at least:

the current candidate and explicit claims;
one or more rivals;
evidence already consulted, with provenance;
unresolved contradictions;
verification actions attempted and their outcomes;
the consequence and remaining budget; and
a stop reason.

This state prevents the loop from presenting the same critique as progress. It also supports replay. A reviewer can see which observation caused revision rather than reading a polished final rationale that reconstructs certainty.

A stopping rule

Let $V_{t}$ be expected reduction in decision loss from another verification action at round $t$ , and $C_{t}$ its compute, latency and harm cost. Continue only while

$V_{t} > C_{t}$

and a permissible test remains. The values may be approximate. The important design move is to make continuation conditional on expected information, not a fixed number of introspective rounds.

Figure 4. More reflection has a stopping point

Reading. Expected repair initially rises, then saturates while revision damage and cost continue. Curves are illustrative.

Repair often rises early because obvious omissions are easy to detect. It then saturates. Revision damage and cost can continue rising. A fixed “reflect three times” rule ignores this shape. Stop sooner when a decisive check passes. Escalate when consequence is high and no discriminating test exists. Preserve an unresolved state rather than manufacturing closure.

Allocate checks by expected information

A controller rarely has budget for every verifier. It should choose the next check whose expected decision value is highest. A cheap schema test comes before a costly human review when either could reject the candidate. A decisive calculation can stop further debate. Retrieval is wasted when the disagreement concerns a local arithmetic step.

Estimate value from historical correction matrices by error class. If tool execution repairs eighty per cent of calculation errors with little damage, it receives high priority. If same-model critique rarely repairs factual errors, do not spend repeated rounds there. Update these estimates as models and tasks change.

Parallel checks can reduce latency when they are independent and likely to matter. They can also waste cost and create conflict. For high-consequence decisions, run a mandatory control set regardless of expected average value. An identity check is not optional because the model feels certain.

When verifiers disagree, do not average incompatible authorities. A compiler decides syntax. A current policy source decides what rule exists. A person may decide a preference. Route conflict according to claim type and preserve the unresolved state where authorities genuinely contest the matter.

Evaluate controllers, not isolated prompts

The unit of evaluation is the complete policy that chooses when and how to reflect. Build cases containing correct and wrong initial answers, several error classes, varying consequence and available verifiers. Compare controllers at matched cost.

Report base accuracy, final accuracy, repair, damage, abstention, escalation quality, verifier calls, latency and cost. Show outcomes by initial confidence and consequence. A controller can raise final accuracy by escalating almost everything; coverage and human burden expose that trade.

Inject verifier faults. Return a stale source, incorrect tool result, unavailable service and ambiguous human review. The controller should recognise degraded evidence rather than treating every check as authoritative. Test duplicate and contradictory observations. Store which evidence caused the final transition.

Use a budget-matched stronger-model baseline. If a more capable first pass beats generation plus reflection, choose it where cost and latency permit. Use reflection where verification is cheaper, information arrives after proposal, or the task benefits from explicit evidence routing. The architecture should be allowed to simplify as models improve.

Finally, test selective reflection. A detector decides which cases need checking. False negatives leave errors untouched; false positives expose correct answers to damage. Evaluate the detector and reviser jointly. High-risk classes may bypass detection and receive mandatory verification.

Keep an audit sample of cases the detector allowed through without reflection. Otherwise the system observes only the work it chose to question and cannot estimate missed errors. Oversample high-confidence failures and cases near action boundaries. A controller that learns solely from escalated cases receives a distorted picture of ordinary performance.

Reflection latency also changes behaviour. A user may abandon a slow answer, an upstream workflow may time out, or a market state may move while verification runs. Measure freshness at the final decision, not only at the initial proposal. If evidence expires during reflection, reacquire it or stop.

For interactive tasks, expose progress without turning provisional text into a commitment. The system can say that it is checking a calculation or source. It should not stream an unverified action instruction that the user may follow before the correction arrives.

A runnable controller

The executable artefact encodes the arithmetic example. It represents a candidate, a rival and an evidence result. Feedback must be independent and discriminating. Independent Python execution supports 323 and rejects 313, so the controller revises. A same-model stylistic critique supports both candidates and is not independent, so a high-consequence case escalates.

. It uses only the Python standard library and includes positive and negative cases.

#!/usr/bin/env python3
"""A reflection controller that requires discriminating evidence."""

from __future__ import annotations

from dataclasses import dataclass
from typing import Callable


@dataclass(frozen=True)
class Candidate:
    answer: int
    rationale: str


@dataclass(frozen=True)
class Evidence:
    source: str
    independent: bool
    supports_candidate: bool
    supports_rival: bool

    @property
    def discriminates(self) -> bool:
        return self.supports_candidate != self.supports_rival


def control_reflection(
    candidate: Candidate,
    rival: Candidate,
    evidence_provider: Callable[[Candidate, Candidate], Evidence],
    consequence: int,
) -> dict:
    evidence = evidence_provider(candidate, rival)
    if not evidence.independent or not evidence.discriminates:
        return {
            "decision": "escalate" if consequence >= 3 else "keep-with-warning",
            "reason": "feedback adds no independent discriminating information",
            "evidence": evidence,
        }
    if evidence.supports_candidate:
        return {"decision": "accept", "answer": candidate.answer, "evidence": evidence}
    return {"decision": "revise", "answer": rival.answer, "evidence": evidence}


def execute_equation(candidate: Candidate, rival: Candidate) -> Evidence:
    # Independent execution of 17 * 19 distinguishes 313 from 323.
    truth = 17 * 19
    return Evidence(
        source="python execution",
        independent=True,
        supports_candidate=candidate.answer == truth,
        supports_rival=rival.answer == truth,
    )


def stylistic_self_critique(candidate: Candidate, rival: Candidate) -> Evidence:
    # A fluent restatement cannot distinguish the numerical claims.
    return Evidence(
        source="same-model prose critique",
        independent=False,
        supports_candidate=True,
        supports_rival=True,
    )


def run() -> None:
    wrong = Candidate(313, "17 times 19 is close to 17 times 18")
    right = Candidate(323, "19 times 10 plus 19 times 7")

    positive = control_reflection(wrong, right, execute_equation, consequence=2)
    negative = control_reflection(wrong, right, stylistic_self_critique, consequence=4)
    print({"tool_grounded": positive, "shared_state": negative})

    assert positive["decision"] == "revise" and positive["answer"] == 323
    assert negative["decision"] == "escalate"


if __name__ == "__main__":
    run()

The artefact separates evidence from authority. Execution decides the multiplication claim; it does not decide whether a consequential action may proceed. The controller still uses consequence to select accept, revise, warn or escalate.

Extend the pattern by replacing the evidence provider. A schema validator can test structure. A database readback can test whether an effect occurred. A policy engine can test permission. A calibrated human review can test a judgement. Each provider should declare scope, freshness, independence and failure semantics.

Production-shaped reflection

Imagine an agent preparing a credit memo. It extracts financial figures, calculates ratios, retrieves policy, identifies exceptions and drafts a recommendation. An unstructured reflection prompt says, “Check your work carefully.” The revised memo sounds more balanced. That is not yet assurance.

Decompose the feedback by claim type.

Extraction claims are checked against located source spans and document identity. Calculation claims are recomputed by deterministic code. Policy claims are retrieved from the effective version and checked against the case date. Exception claims are tested through explicit rules. Recommendation claims are compared with alternatives and remain subject to accountable human decision.

The generator does not receive authority to change source values or policy. A correction creates a revision receipt: original claim, rival, evidence, verifier, result and changed decision. The final memo distinguishes observed evidence from model proposal.

Worked minimal example

A model answers a scheduling request with 14:00. The calendar tool returns a conflict at 14:00 and availability at 15:00. The observation discriminates the candidates. The agent revises to 15:00, but it does not send the invitation automatically if the user authorised only drafting. Reflection changes the proposal, not the authority boundary.

Worked high-consequence example

A payment agent proposes sending £25,000 to a beneficiary. Its self-critique finds no issue. An independent verification route checks beneficiary identity, available balance, transaction purpose, sanctions status, duplicate intent and user confirmation freshness. One check reports that the confirmation covered £2,500, not £25,000.

The right outcome is not another language-model debate. The typed mismatch blocks execution. The agent can ask for a fresh confirmation or escalate. This case shows why consequence must shape the feedback channel. Fluent reflection is suitable for drafting. Irreversible effects require model-independent controls.

Figure 6. Confidence, consequence and evidence should move together

Reading. High consequence raises the evidence threshold; confidence alone should not shorten the route. Practitioner synthesis.

Confidence, evidence and consequence should move together. High confidence with weak evidence does not permit a high-consequence action. Strong evidence can justify a bounded decision even when the model reports uncertainty. Consequence raises the threshold and may require independent approval.

How the claim changes under pressureChart · state

stateDiagram-v2
  [*] --> Claim
  state "Figure 1. Reflection can<br/>recycle an error or meet new<br/>evidence" as Claim
  state "Reflection has several mechanisms" as Test
  state "Thought experiment, two<br/>mirrored rooms" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

The revision loop begins with Figure 1. Reflection can recycle an… and keeps counterexamples inside the reasoning path. Reading use: follow the relation, then test it against the surrounding evidence and limits.

The reflection decision record

Figure 7. A reflection controller chooses among four moves

Reading. The controller may accept, revise, verify or escalate. Repetition is not a fifth move.

Field	Question	Failure signal
Error class	Is the suspected defect factual, logical, structural, procedural or preferential?	Critic gives generic comments unrelated to the class
Rival	What alternative answer or explanation could be true?	No explicit competing candidate
Discriminating test	Which observation should differ between candidate and rival?	Feedback is compatible with both
Independence	Which model, context, data and objective are shared?	Roles differ but evidence path is identical
Correction matrix	How often are wrong answers repaired and correct answers damaged?	Only final aggregate accuracy is reported
Stop rule	When does expected information fall below cost?	Fixed rounds continue after evidence saturates
Consequence	What action becomes possible if the answer is accepted?	Reflection silently acquires execution authority
Receipt	Which observation caused which revision?	Only a polished final rationale remains

The record supports a matched experiment. Compare the base model, extra resampling, self-critique, independent critique, tool-grounded verification and a budget-matched stronger generator. Hold the information and token budget as fairly as possible. Report correction transitions, calibration, latency and cost by task type.

The stronger-generator baseline is important. Reflection may help only because it spends more inference. If one larger or longer initial solve performs better at the same cost, the loop is unnecessary. Conversely, a cheap generator plus a precise verifier may dominate for tasks with executable checks.

Where reflection stops helping

The central failure boundary is shared error. Generator, critic and judge may inherit the same training correlations, source omissions, prompt frame or cultural assumption. Agreement then measures consistency within a blind spot.

Figure 8. Shared blind spots define the failure boundary

Reading. When generator, critic and judge share data, model and framing, apparent agreement does not multiply evidence. Risk surface is illustrative.

Reflection also fails when the task has no accessible feedback before action. A one-off strategic choice may reveal its outcome years later. The system can compare scenarios and assumptions, but it cannot verify the future. It should preserve uncertainty and support human judgement rather than describe simulation as correction.

Adversarial contexts create another boundary. Untrusted content can instruct the critic to approve the proposal. Tool outputs can be poisoned. Memory can preserve false lessons. Verification inputs need provenance and authority controls. A reflected answer is not safer merely because it has passed through more text.

The strongest objection

Humans often improve work by rereading without external tools. Models can do the same. They may notice an omitted condition already present in context, recompute a step or sample a representation that exposes the error. Requiring external evidence for every revision would discard genuine capability.

The objection is correct. The mechanism does not require externality; it requires discriminating information. A second pass can attend to evidence the first ignored. Diverse sampling can surface a rival. Explicit decomposition can make a contradiction visible. These are valid internal mechanisms. Their reliability must be measured by error class, and their shared blind spots remain a boundary.

In operation, audit a fresh sample of accepted and rejected revisions. Classify the evidence path, whether the original answer was correct, whether the critic located a real defect and whether the final change improved the bounded claim. Keep the untouched first answer. Without it, teams cannot distinguish correction from confident rewriting. Sample more heavily after model, prompt, tool or source changes, because yesterday’s preservation rate does not license tomorrow’s loop.

For streaming work, freshness becomes part of independence. A critic reading the same cached retrieval result is not an independent check merely because it runs later. Record source timestamps and cache identities. When the decision depends on a changing fact, require a permitted refresh or preserve an unresolved state. Reflection cannot manufacture recency from stale context.

Give the loop something capable of saying no

The arithmetic example did not need an elaborate society of critics. It needed one check whose outcome differed between 313 and 323. That is the design lesson.

Begin with the candidate and a credible rival. Choose the smallest permissible observation that separates them. Protect the observation from being rewritten by the proposal. Measure preservation and damage, not only final score. Stop when the evidence settles the bounded claim or when another round cannot add enough information. Escalate unresolved high-consequence cases.

Reflection becomes reliable when the loop can encounter resistance. Sometimes that resistance is a contradiction already in context. Often it is code execution, a source, a policy rule, an environment state or an accountable reviewer. Without it, the model may still write a better answer. It has not necessarily learned that its answer was wrong.

The evidence conversationChart · sequence

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The second answer that sounded more certain
  M->>E: Figure 1. Reflection can recycle an error or meet new evidence
  E-->>M: compare rival explanations
  E->>D: Sources
  D-->>Q: revise scope or act

Question, mechanism, evidence and decision exchange the burdens developed in Reflection and Self-Correction Under Controlled Evidence. Reading use: follow the relation, then test it against the surrounding evidence and limits.

Sources

Primary Shinn et al., Reflexion: Language Agents with Verbal Reinforcement Learning, 2023.
Primary Madaan et al., Self-Refine: Iterative Refinement with Self-Feedback, 2023.
Primary Gou et al., CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing, 2023.
Primary Huang et al., Large Language Models Cannot Self-Correct Reasoning Yet, 2023.
Primary Valmeekam et al., Can Large Language Models Really Improve by Self-critiquing Their Own Plans?, 2023.
Primary Wang et al., Self-Consistency Improves Chain of Thought Reasoning in Language Models, 2022.
Primary Lightman et al., Let’s Verify Step by Step, 2023.
Primary Saunders et al., Self-Critiquing Models for Assisting Human Evaluators, 2022.