Agent Patterns

Overview

You have decided a path warrants a loop. The loop has a shape, and the shape is a design decision with consequences for cost, latency and — most usefully — for where a human can intervene.

Three patterns are worth knowing. The interesting criterion for choosing between them is not sophistication; it is the shape of the task and where oversight needs to sit.

Three shapes

ReAct — reason and act, interleaved. The system thinks, calls one tool, sees the result, thinks again. The path emerges one step at a time, and the next step genuinely depends on the last observation.

Plan-and-Solve — decompose first, then execute. The system produces a plan, then carries it out. The plan exists as an artifact before anything happens.

Reflexion — act, then critique the result, then revise. A self-correction loop wrapped around either of the above.

A fourth arrangement worth naming, because it is the cost-shaped variant: a planner/executor split, where a more capable model is consulted for planning while a cheaper one does the bulk of the work. It is not multi-agent in any meaningful sense — one loop, with advice — and it addresses the common case where reasoning quality matters at step one and matters much less thereafter.

Matching pattern to task shape

graph TD
  Q{"What shape is<br/>the task?"} -->|"depth unknown,<br/>each result changes<br/>the next step"| R["<b>ReAct</b><br/>exploratory,<br/>emergent path"]
  Q -->|"structure knowable<br/>up front, and someone<br/>should approve it"| P["<b>Plan-and-Solve</b><br/>reviewable plan,<br/>then execution"]
  Q -->|"output has a<br/>checkable quality<br/>signal"| F["<b>Reflexion</b><br/>critique and<br/>revise"]
  Q -->|"planning quality matters,<br/>bulk work does not"| A["<b>Planner/executor</b><br/>capable model advises,<br/>cheap model executes"]

  classDef gate fill:#5B8FB9,stroke:#4A7A9E,stroke-width:2px,color:#ffffff
  classDef explore fill:#E8A33D,stroke:#C4832A,stroke-width:2px,color:#ffffff
  classDef gated fill:#7D9A4E,stroke:#5F7A38,stroke-width:2px,color:#ffffff
  classDef risky fill:#D9695B,stroke:#B4483A,stroke-width:2px,color:#ffffff
  class Q gate
  class R,A explore
  class P gated
  class F risky

Task shape chooses the pattern. The olive leaf is the only one that produces a human-inspectable artifact before anything happens, which is why it suits consequential work.

The insight worth taking away

Of the three, Plan-and-Solve is the only one that produces a human-inspectable artifact before anything irreversible happens.

That single property makes it the natural choice for consequential work, and the reasoning has nothing to do with the quality of the plans. A plan is a thing a person can read, approve, amend or reject — which means the pattern creates an oversight point for free, in exactly the place the previous topic said the fourth criterion was failing.

ReAct offers no such point. By the time you see what it did, it has done it. You can gate individual tool calls, and the next two topics are about doing exactly that, but you cannot review the shape of the work in advance because the shape does not exist in advance.

So when a loop takes consequential actions, the pattern choice and the oversight model are the same decision.

Failure modes, by pattern

Each pattern fails in a characteristic way, and knowing which one you have chosen tells you what to watch for.

ReAct wanders. With no global view, it pursues a local thread, discovers it was wrong, backtracks, and spends your budget doing it. The detection signal is step-count distribution: a long tail of interactions taking many more steps than the median. The structural response is bounds, which is the next topic.

Plan-and-Solve follows a wrong plan faithfully. The failure is upstream: if step one produced a bad decomposition, execution proceeds competently off a cliff, and each step looks locally reasonable. The detection signal is failures that are coherent — a clean, well-executed sequence that achieved the wrong thing. The response is the gate: review the plan, not the steps.

Reflexion converges confidently. This is the dangerous one. Self-critique is not independent review — the same model that produced the answer is assessing it, with the same blind spots. A critique loop can increase an answer’s confidence without increasing its correctness, and it costs several times the tokens to do so. Module 7 returns to this as hallucination amplification; the short version is that a critic sharing the author’s assumptions is not a check.

Reflexion earns its cost when there is a genuinely independent signal to critique against — a test that runs, a schema that validates, a calculation that can be verified, a retrieval that either supports the claim or does not. Against a signal the model generates itself, be sceptical.

What all three cost

Latency multiplies by the number of iterations, and the iterations are sequential. Cost multiplies similarly, with the added problem that the multiplier is not known in advance. And every pattern makes the same architectural demand: the history of the loop accumulates in context, which is a budget with a hard ceiling — the subject of a topic in Section 2.

Plan, confirm, execute

The action path takes three kinds of action: reschedule a job, issue a credit, reset a device.

Pattern: Plan-and-Solve, with the plan as the confirmation surface. The loop establishes what it believes should happen — “move job 4471 from Thursday 14:00 to Friday 09:00, because the customer says the site is inaccessible Thursday” — and that statement is what gets shown, logged, and where required, approved.

Why not ReAct: the actions are consequential and Module 1’s blast-radius tiers put credits behind a confirmation. A pattern with no pre-action artifact gives Dev Raghunathan nothing to approve and Lena Fischer nothing to audit. The oversight requirement selects the pattern.

Why not Reflexion: there is no independent quality signal for “was this the right reschedule”. A second pass by the same model would add cost and latency against the $2.50 p95 ceiling while producing more confident wrong answers — which is the 2023 failure mode, reached by a new route.

The planner/executor split is worth testing rather than assuming. Planning quality is what matters here; the execution steps are API calls. A more capable model producing the plan and a cheaper one carrying it out could hold quality at lower cost — but Module 4’s cache-scoping finding applies, so it is a measured bet, not a default.

The eventual shape: plan → classify by blast radius → confirm if required → execute with idempotency → verify → record. Four of those six steps exist because of the oversight requirement rather than the task.

Feeds the workbook

Your agent design should name the pattern and justify it by task shape and oversight requirement, not by sophistication. If you choose Plan-and-Solve, say explicitly what the plan is used for — because its value as a gate is most of why you chose it.

Check your understanding

1. Your loop is ReAct and an action went wrong. What could a human have reviewed beforehand? If nothing, what does that tell you about the pattern choice?
2. Name an independent signal that would make Reflexion worth its cost on the action path. If you cannot find one, what follows?
3. The step-count distribution has a long tail. Which pattern’s failure mode does that suggest, and what would you check next?

---

→ Every pattern above can run forever. Four kinds of bound, and you need more than one. — Bounding the loop