The 7 Canonical LLM Agent Design Patterns and When Each One Wins

**Structure:** One LLM call. Input goes in, output comes out. No tools, no iteration, no decomposition. The 'agent' is really just structured prompting.

**Workload signature:** Task fully specified in the input, output bounded and verifiable, no external information needed beyond what's in the prompt + model knowledge. Examples: text summarization, paraphrasing, classification with stable label set, simple Q&A from supplied context.

**Cost:** 1 model call. Cheapest and fastest of all patterns. Latency: single-call latency (typically 1-5 seconds depending on model + output length).

**Failure mode:** Use single-shot when the workload genuinely needs information not in the prompt (then it hallucinates) or when the workload requires multi-step reasoning (then it produces shallow output).

**Structure:** LLM call with a defined tool schema. Model decides whether to invoke tools, parses tool outputs into prompt context, generates final response. Single iteration through the loop or capped iterations.

**Workload signature:** Task requires external information (database lookup, API call, calculation), tool surface is small (<10 tools), tools are simple (deterministic, predictable).

**Cost:** 1-3 model calls typically (initial + tool result + final response). Latency: 2-8 seconds typical.

**Failure mode:** Tool surface too large (>15 tools) — model gets confused about which to call. Tools too complex (chained dependencies) — needs Plan-Execute instead. See Anthropic's tool use documentation for boundaries.

**Structure:** Model alternates between 'Thought' (reasoning about what to do next) and 'Action' (invoking a tool) in a loop until task completion. Each iteration: reason, act, observe result, reason about result, act again.

**Workload signature:** Multi-step reasoning required where each step depends on the previous step's result. Tools available but not all are needed for every query. Tasks like research, data analysis, multi-step computation.

**Cost:** 3-15 model calls depending on task complexity. Latency: 10-60 seconds. Per-task cost can be 3-15× single-shot.

**Failure mode:** Loops forever if no termination condition is well-defined. Wastes tokens when single-shot would have sufficed. Original paper: Yao et al. 2023, arXiv:2210.03629.

**Structure:** Two-stage: a planner LLM call creates a multi-step plan, then an executor model executes each step (often using Tool Use pattern). Planner sees the big picture; executor focuses on individual steps.

**Workload signature:** Complex multi-step tasks where the sequence of steps matters and benefits from upfront planning. Tasks where executor capability differs from planner capability (e.g., planner is frontier model, executor is cheaper model).

**Cost:** 1 planner call + N executor calls (N = plan length, typically 5-15). Latency: 30 seconds to several minutes. Cost varies based on plan length.

**Failure mode:** Plans that don't survive contact with reality — executor encounters surprises that weren't anticipated. Requires re-planning logic if plans frequently fail. See Anthropic's orchestrator-worker pattern documentation.

**Structure:** Initial generation followed by a critique pass that evaluates the output against criteria, then a revision pass that improves based on the critique. Can iterate 2-5 times.

**Workload signature:** Quality matters more than cost or speed. Output has subjective dimensions (writing quality, code elegance, argument strength) that benefit from critique. Tasks where single-shot output is good-but-not-great and you want great.

**Cost:** 2-5× single-shot. Latency: 3-15× single-shot. Quality typically improves 20-40% on subjective rubrics.

**Failure mode:** Marginal improvement after 2-3 iterations (diminishing returns). Critique can produce false-positive flaws (model criticizes things that were actually fine). See Shinn et al. 2023 'Reflexion' paper for the academic framework.

**Structure:** A small classification model (or cheap LLM call) routes incoming requests to specialized handlers — different prompts, different models, different downstream pipelines. The router is fast; the handlers are deep.

**Workload signature:** Diverse inbound query types where different queries benefit from different processing. Examples: support ticket triage (billing → handler A, technical → handler B, refund → handler C), content classification before specialized generation.

**Cost:** 1 routing call + 1 handler call typically. Latency: small overhead from router (typically <500ms). Cost dominated by the handler tier chosen.

**Failure mode:** Router misclassifies edge cases, sending them to wrong handlers. Mitigation: log misclassifications, retrain router with corrected examples. Anthropic's routing pattern documentation covers boundaries.

**Structure:** Multiple agents with different roles (researcher, critic, planner, executor) collaborate on a shared task via structured handoffs. Each agent has its own prompt, tools, and sometimes its own model.

**Workload signature:** Tasks that benefit from genuine specialization OR adversarial evaluation. Examples: deep research (researcher + skeptic + synthesizer), code generation with built-in code review (writer + reviewer + tester).

**Cost:** 5-50× single-shot depending on number of agents and rounds. Latency: minutes to hours. Highest cost of all patterns.

**Failure mode:** Pattern abuse — using multi-agent when single-shot + reflection would suffice. Most multi-agent systems in production should have been simpler patterns. Per Anthropic's research, the multi-agent overhead is justified only when the task genuinely requires multiple distinct cognitive roles.

Pattern picked by trend ('we need an agent'): team builds Multi-Agent or Plan-Execute for workloads that would have shipped in single-shot. Months of engineering, expensive token bills, marginal quality lift.
Pattern picked by workload signature: single-shot for simple, Tool Use for external info, ReAct for multi-step reasoning, Routing for diverse inputs, Plan-Execute for complex sequences, Reflection for quality-critical, Multi-Agent only for true role-specialization. Ships faster, costs less.