The choice is not whether to plan, it is when
Every agent that does more than one thing is planning in some sense, deciding what to do next given a goal. The design question the research actually settles is whether that plan is produced once, up front, and then executed, or produced incrementally, checked against what actually happened at each step, and revised. This page is about that choice. Planning is not a single monolithic technique.
ReAct: interleave reasoning and acting, rather than separating them
Before ReAct, reasoning (chain-of-thought: think through a problem in text before answering) and acting (generate an action, execute it, observe the result) had mostly been studied as separate capabilities. ReAct’s specific contribution was interleaving them: at each step, the model produces a reasoning trace and an action, in alternation, so each action is grounded in an explicit chain of reasoning that is itself updated by what the previous action returned.
The practical effect the paper demonstrates is recovery from being wrong partway through. On multi-step tasks, a model that reasons only once at the start and then executes a fixed sequence of actions has no mechanism to notice that an early step returned something unexpected and adjust. ReAct’s interleaving means each new reasoning step has the actual observation from the previous action available to reason over. The model can revise its plan because the plan was never fully fixed to begin with. The paper reports this directly reduces hallucination and error propagation on knowledge-intensive tasks (question answering, fact verification) compared to reasoning-only baselines, because the model can check its assumptions against a real tool result instead of reasoning purely from what it already believes.
Reflexion: use verbal self-critique instead of retraining
Reflexion addresses a different part of the same problem: what happens after an attempt fails. Updating model weights is expensive, and not available to most teams building on top of an API model. So instead, Reflexion has the agent verbally reflect on what went wrong in its own natural language, store that reflection in an episodic memory buffer, and carry it into the next attempt at the same or a similar task. The mechanism connects directly to agent memory: a plan is not just revised within a single attempt, it can be revised across attempts, using a memory of what specifically failed last time. The next attempt does not start cold.
The paper’s own headline result: Reflexion agents reached 91% pass@1 on the HumanEval coding benchmark, exceeding the GPT-4 baseline’s 80% at the time of publication, from the same underlying model. The improvement came entirely from the verbal-feedback-and-retry loop, not from a different or larger model. That gap is the concrete case for treating self-critique as a first-class part of an agent’s planning loop rather than an optional extra.
Generative Agents: planning as one stage in a larger loop, not a standalone step
Generative Agents’ architecture places planning between retrieval and action, not before everything else: relevant memories are retrieved first, those retrieved memories and reflections inform a high-level plan, and the plan is then recursively broken down into the specific behaviour needed right now. Plans and the reflections that produced them are written back into the same memory stream. A later planning step can therefore draw on the outcome of an earlier one. The structural point worth taking from this, independent of the specific simulated-agents setting the paper demonstrates it in, is that planning is not a separate module bolted onto a memory system and an action system. The three feed each other continuously.
What actually distinguishes a fragile plan from a robust one
Across these three, the common thread is not a specific algorithm, it is where revision happens:
- A fixed plan-then-execute agent commits to a sequence before acting and has no structural point at which an unexpected result changes the remaining steps.
- ReAct-style interleaving revises the plan at every step, using the immediately preceding observation.
- Reflexion-style reflection revises across attempts at the same task, using an explicit, retained self-critique, not only the current step’s result.
- Generative Agents’ reflection-into-memory revises the inputs future planning draws on, not just the current plan, by feeding synthesised conclusions back into the same store retrieval pulls from.
None of these make a plan correct. They make a wrong plan recoverable, which is the property that actually matters once an agent is calling real tools with real, sometimes surprising, results.
Failure modes
- Planning entirely up front with no revision point. Works only if every tool call returns exactly what was expected; degrades hard the first time it does not.
- Treating every failure as a reason to replan from scratch. Without Reflexion-style retained self-critique, an agent can retry a failed approach with only cosmetic changes, because nothing carried forward what specifically was wrong last time.
- Confusing more reasoning steps with better planning. ReAct’s improvement comes from grounding reasoning in real observations, not from generating more reasoning text; a longer chain of thought with no tool calls to check it against does not get the same benefit.
- No connection between planning and memory. A planning loop that cannot retrieve what happened in a previous session or a previous attempt at the same task repeats avoidable mistakes - see agent memory for the retrieval side of this.
What to watch
- Whether interleaved reasoning-and-acting (ReAct’s core idea) or fixed upfront planning becomes the default in production agent frameworks, as opposed to the pattern currently common in simpler single-tool-call agents.
- Whether verbal self-reflection (Reflexion’s mechanism) or a numeric reward signal becomes the more common way production systems incorporate feedback from failed attempts, given that verbal reflection requires no model retraining but numeric signals are easier to aggregate at scale.