Reflection is a technique in agentic AI systems where a model generates an initial output, then critiques or evaluates that output (often by generating a separate reasoning trace or using a secondary model), and finally revises the output based on the critique. This loop can repeat multiple times, enabling the system to self-correct without human intervention.
Technically, reflection is implemented by prompting the model to produce a chain-of-thought (CoT) that includes a self-evaluation step. For example, the model might first answer a question, then generate a list of potential flaws or missing details, and then produce a revised answer. In more advanced implementations (e.g., Reflexion by Shinn et al., 2023), the model maintains a persistent memory of past failures and successes (a “trajectory store”), using that to inform future attempts. Another variant uses a separate “critic” model (often a smaller, fine-tuned model) that scores or comments on the primary model’s output, feeding that feedback into the next generation step.
Why it matters: Reflection addresses a fundamental weakness of LLMs — their tendency to produce plausible but incorrect or shallow answers. By forcing the model to examine its own reasoning, reflection improves factual accuracy, reduces hallucination, and enhances reasoning depth. In agentic systems (e.g., code generation, multi-step planning), reflection allows agents to recover from errors mid-task, dramatically improving task completion rates. For instance, in the SWE-bench coding benchmark, agentic systems using reflection (e.g., Devin, SWE-agent with reflection) achieve >30% resolution rates vs. ~15% without.
When to use: Reflection is most beneficial for tasks requiring high accuracy, complex reasoning, or multi-step verification (e.g., medical diagnosis, legal analysis, code debugging). It is less useful for simple, single-turn tasks where latency is critical, as each reflection loop adds generation time and cost. Alternatives include using a single, more powerful model (e.g., GPT-4 vs. GPT-3.5), but reflection with a smaller model can match or exceed a larger model’s performance at lower cost. Another alternative is external tool use (e.g., calling a calculator or search API) for verification, which is faster but less flexible.
Common pitfalls: (1) Over-correction — the model may revise a correct answer into an incorrect one. (2) Looping — without a termination condition, the model may iterate indefinitely or produce diminishing returns. (3) Confirmation bias — the critic may reinforce the original output’s errors if not prompted to be adversarial. (4) Cost — each reflection loop multiplies token usage, which can be prohibitive at scale.
State of the art (2026): Reflection is now a standard component in most production agent frameworks (LangChain, AutoGPT, CrewAI). The latest frontier models (e.g., Gemini 2.0, Claude 4, GPT-5) include native self-reflection capabilities, often via internal “critique tokens” or specialized fine-tuning. Research has moved toward multi-agent reflection (multiple LLMs critique each other) and hybrid reflection (combining LLM critique with symbolic verification). A 2025 paper from Anthropic showed that reflection with a dedicated “reasoning verifier” model improved accuracy on MATH-500 from 78% to 92%. The technique is also being applied to multimodal tasks, where vision-language models reflect on their own visual interpretations.