Flashcard: how does Reflexion let an agent learn from failed runs?

Flashcard·Easy·4.0 · 0·~30s

Attempt it

Reflexion (Shinn et al. 2023, arXiv 2303.11366) is a pattern where the agent attempts a task, observes failure, writes a 'reflection' (a short natural-language post-mortem describing what went wrong and what to try differently), and stores that reflection in episodic memory. On the next attempt, the stored reflection is prepended to the prompt as context. The agent learns from its own failures across attempts without any weight updates. What it lets an agent do that a single ReAct run cannot: improve performance on the same task type over multiple trials by accumulating self-generated lessons. Reflexion adds a meta layer on top of ReAct: the inner loop is still Thought, Action, Observation; the outer loop is attempt, reflect, retry. The reflection is the bridge between trials, turning episodic experience into in-context learning signal.

Your answer

**Reflexion** is a pattern that lets an agent learn from its own failures without any training. It works in three steps. First, the agent attempts the task using whatever inner loop it has (often ReAct). If the attempt succeeds, nothing extra happens. If it fails (a test does not pass, an answer is wrong, the task times out), a signal indicates the failure. Second, the agent runs a reflection step. It reads the trace of its attempt and writes a short natural-language post-mortem: what it tried, what went wrong, and what to do differently next time. This reflection is just text. Third, the reflection is stored in an episodic memory keyed by the task type. On the next attempt at a similar task, the stored reflection is prepended to the prompt as context. The agent does not update any weights. The learning lives entirely in the self-written reflection that is fed back as in-context input. Across many attempts, the agent accumulates a small library of lessons it wrote for itself. Reflexion was introduced by Shinn et al. in 2023 and pairs naturally with ReAct as an outer loop on top of the inner Thought-Action-Observation cycle.

**Reflexion** is an agent pattern where the agent attempts a task, observes failure, writes a natural-language reflection on what went wrong, stores the reflection in episodic memory, and uses it as context on the next attempt. The pattern lets an agent improve across trials without any weight updates. The loop has two levels. The inner loop is the standard agent run, typically ReAct: Thought, Action, Observation, repeat. The outer loop adds a reflection step. After each completed attempt (success or failure), the agent evaluates the outcome. On failure, it produces a reflection: a short summary of what it tried, why it failed, and what to do differently. The reflection is stored, keyed by the task type. On the next attempt, the stored reflections for that task type are prepended to the prompt. The agent reads its own past lessons before starting and adjusts its strategy. The key insight is that learning happens in context, not in weights. No gradient flows; the model parameters never change. The reflection is just text, and the agent's improved performance comes from in-context learning conditioned on its own past failures. What Reflexion lets an agent do that a single ReAct run cannot: improve on the same task type over multiple trials by accumulating self-generated lessons. Shinn et al. 2023 showed measurable gains on HumanEval, AlfWorld, and HotpotQA from this outer loop alone, without any model retraining.

Quick reference

TL;DR

Reflexion has the agent attempt a task, fail, write a natural-language post-mortem to episodic memory, and prepend that reflection on the next attempt. The agent learns from failure without any weight updates.

Memory aid

Easy to grasp

Imagine a student who fails a coding test, then sits down and writes a one-paragraph note to their future self: I used the wrong loop, I forgot the base case, next time check the edge cases first. They paste that note on their desk. The next time they take a similar test, they read the note before starting. They are not any smarter in the brain sense, but they are smarter in the context sense because the note tells them what to avoid. Reflexion does exactly that for an AI agent. After a failed attempt, the agent writes a short reflection about what went wrong, stores it, and reads it before the next attempt. No retraining, just self-written notes that make the next try better.

Key concepts

Reflexion Self-reflection Episodic Memory In-context Learning

Detailed answer & concept explanation

~6 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.

Quick scan · 2–4 min

Everything important, quickly.

Define Reflexion as an outer loop that attempts, reflects on failure in natural language, stores the reflection, and retries with it in context. Stress that no weights update. Name the four components: actor, evaluator, reflection module, episodic memory. Attribute to Shinn et al. 2023. Close with the two main failure modes: bad evaluator and unfiltered memory retrieval.

Real-world examples

Real products, models, and research that use this idea.

Cursor and Cline coding agents store a per-task scratchpad of what they tried; on a failed test, the next iteration reads the scratchpad to avoid repeating the mistake.
Anthropic claude-code uses a Reflexion-style outer loop when running a long refactor: failed test output becomes a reflection that informs the next edit attempt.
Voyager (an open-ended Minecraft agent built on GPT-4) used a Reflexion-style skill library where failed attempts produced reflections that informed future skill acquisitions.
OpenAI's o3 reasoning model and GPT-5.5 with extended thinking embed Reflexion-style self-correction internally within their hidden reasoning loop, generating self-critiques before emitting the visible answer.

Interviewer follow-ups

What an interviewer would ask next. Try answering before peeking at the approach.

QHow does Reflexion differ from self-refine, in one sentence?

QWhy is the evaluator a load-bearing component of the Reflexion loop?

QHow does Reflexion compare to fine-tuning on the same task domain?

Don't say this

Red flags and common mistakes that signal junior thinking. Click to expand.

Most common mistake

Calling Reflexion a fine-tuning method or a weight update. The whole point is that no weights change; the learning lives in a self-written reflection that is fed back as in-context input.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

References

Primary sources. Skim if you want the original framing.

Shinn et al., Reflexion: Language Agents with Verbal Reinforcement Learning