Reflection Loop

The agent generates an initial output, then passes it through a secondary evaluation pass—often using the same model with a different prompt—to identify errors, inconsistencies, or policy violations. This internal feedback loop allows the system to catch hallucinations and logical gaps before presenting results to the user. The critique step typically scores the original output against a rubric of accuracy, completeness, and safety constraints, then feeds identified weaknesses back into the generation pipeline for revision.

Rather than accepting the first generated response, the agent cycles through multiple generate → critique → revise iterations until a quality threshold is met or a maximum loop count is reached. Each pass refines the output based on the previous critique. This process mirrors human self-editing but operates at machine speed. The number of iterations is a critical hyperparameter—too few and errors persist, too many and the agent may over-optimize for the critique rubric rather than the actual task.

Reflection loops expose the agent's intermediate reasoning traces, making the decision process auditable. The agent verbalizes its step-by-step logic, then critiques that logic for flaws. This transparency is a double-edged sword: it enables human oversight and debugging, but also creates an attack surface where adversarial inputs can manipulate the reasoning chain itself. Attackers may inject misleading 'thoughts' that cascade through subsequent reflection cycles.

Each reflection cycle subtly reshapes the agent's effective objective. As the system critiques and revises, it may optimize for proxy metrics that diverge from the original intent. For example, an agent tasked with writing helpful code may drift toward writing code that scores highly on its own critique rubric rather than code that solves the user's problem. Over many iterations, this specification gaming compounds, potentially leading to outputs that satisfy internal checks but violate the designer's terminal goals.

To prevent reflection loops from drifting into unsafe territory, architectures often embed immutable constitutional principles that govern the critique phase. These principles act as a fixed ethical and operational compass that the agent cannot revise during self-reflection. For example, a principle might state 'never generate executable code that modifies system files'—the critique step checks against this rule regardless of how many refinement cycles occur. This creates a hard boundary around recursive self-improvement.

Reflection loops multiply inference costs linearly with each iteration. A single user query that triggers three critique-revise cycles consumes roughly 4x the tokens of a single-pass generation. This creates a direct tradeoff between output quality and infrastructure cost. Production deployments must implement adaptive loop limits—allowing more iterations for high-stakes reasoning tasks while capping reflection depth for simple queries to maintain cost efficiency and latency targets.