ReAct, Plan-Execute, Reflexion

The design-patterns lesson covered the workflow shapes (prompt chaining, routing, parallelization). This lesson is about the reasoning loops an agent runs inside those shapes — how it actually decides what to do next. Three dominate the field, and knowing which to reach for is the difference between an agent that’s reliable and one that’s slow, expensive, or brittle.

ReAct — reason and act, interleaved

ReAct (Reason + Act) is the workhorse. The agent loops: Thought → Action → Observation → Thought → … — it reasons about what to do, takes one action (a tool call), observes the result, and reasons again with that new information. Because it reacts to each observation, it handles dynamic situations gracefully — it doesn’t need to know the steps in advance.

The cost: an LLM call per step, so a long task is many calls (latency and money), and it can wander or loop if the stop condition is loose. ReAct is the default shape behind most tool-using agents.

Plan-and-Execute — decide everything first

Plan-and-Execute splits reasoning from doing. A planner LLM lays out all the steps up front; an executor then runs them, often without calling the planner again. This is cheaper and more predictable — one expensive planning call, then mechanical execution — and easier to debug because the plan is explicit.

The weakness: it’s blind to surprises. If step 2 returns something the plan didn’t anticipate, a pure plan-execute agent plows ahead. In practice you add a re-plan step when execution deviates — a hybrid that recovers some of ReAct’s adaptivity.

Reflexion — try, critique, retry

Reflexion adds a self-correction loop: the agent makes an attempt, then a reflection step critiques its own output (“I cited the wrong policy section”), and it retries with that feedback. It trades extra passes for quality, and it shines when first attempts often fail and the result can be checked — code that must pass tests, structured extraction you can validate, math you can verify.

In one breath

• These are the reasoning loops an agent runs inside a workflow shape — how it decides the next move.
• ReAct interleaves Thought → Action → Observation, reasoning again after each result — adaptive, but one LLM call per step and can wander.
• Plan-and-Execute plans every step up front then runs them mechanically — cheaper and predictable, but blind to surprises unless you add a re-plan step.
• Reflexion attempts, self-critiques, and retries — best when first tries fail and the result is checkable (tests, validation, math).
• Pick the simplest loop the task needs (dynamic → ReAct, known multi-step → Plan-Execute, checkable-hard → Reflexion), combine when useful, and always cap the budget.

Quick check

Next

These loops run inside a single agent. When one agent isn’t enough, see multi-agent orchestration — and the equally important question of when not to go multi-agent.