15 Crucial AI Agent
Design Patterns

ReAct (Reason + Act) is the foundational pattern for tool-using agents. It works by interleaving reasoning traces with concrete tool calls in a tight loop: the agent writes out its thinking, calls a tool, reads the result, updates its thinking, and repeats until it reaches a conclusion. This reasoning transparency is both its strength and its signature — every tool call is preceded by a visible rationale.

Originally described in Yao et al. (2022), ReAct is the default single-agent architecture in LangGraph, LangChain, and the OpenAI Agents SDK. Its adaptability is unmatched: the same loop handles search, code execution, database queries, and API calls with no structural change — only the tool set changes. The loop terminates when the agent either reaches a satisfactory answer or exhausts a configurable step budget.

Primary failure mode: reasoning drift in long loops — the agent loses track of the original goal as intermediate observations accumulate. Mitigation: inject the original goal into every reasoning step’s context and set conservative step budgets (typically 5–15 steps depending on task complexity).

Where ReAct decides what to do next one step at a time, Plan-and-Execute separates strategy from execution. A planner agent first generates a complete, ordered task plan for the full goal. A separate executor agent then runs each step sequentially, following the plan without replanning between steps — unless an explicit replanning trigger is hit.

The core advantage is predictability: you know exactly what steps will run before they start, making the system auditable, budget-estimable, and easier to parallelize. A law firm using this pattern for contract generation runs template selection → clause customisation → compliance review → risk assessment as a declared pipeline, with each step handed to the appropriate specialist.

Primary failure mode: plan brittleness — the plan assumes conditions that change during execution. The fix is iterative replanning: if a step fails or its context changes materially, route back to the planner with the current state before continuing. Single-query planning is faster but brittle; iterative replanning adapts but costs more.

The Reflection pattern adds a self-evaluation loop: after generating an initial output, the agent reviews its own work against defined quality criteria, identifies weaknesses, and generates a revised version. This cycle repeats until the agent’s self-assessment declares the output satisfactory or a maximum iteration count is reached.

The evidence base is compelling: Reflection improved coding benchmark performance (HumanEval) from 80% to 91%. When paired with external verifiers like unit test runners, accuracy gains can exceed 30 percentage points — making Reflection one of the most cost-effective quality patterns for production agents. The Reflexion framework (Shinn et al., 2023) formalised this by having agents maintain a verbal memory of their past mistakes, enabling cross-session learning from failure.

Primary failure mode: sycophantic self-evaluation — the agent convinces itself its first output was fine when it was not. The fix is to use a different model (or temperature) for critique than for generation, and to provide explicit rubric criteria rather than open-ended “review this” instructions.

Tool Use is the primitive that transforms an LLM from a reasoning engine into an actor. The agent is given a registry of available tools — search engines, databases, calculators, code interpreters, APIs, file systems — and learns to select and invoke the right tool for each step of a task rather than hallucinating information from parametric memory.

The critical architectural rule — enforced by the harness — is that the LLM never calls tools directly. The model returns a structured tool-call specification; the harness validates the schema, checks permissions, executes, and injects the result back. This prevents prompt injection from escalating to arbitrary code execution. Tool use is the foundation of RAG (search tool), agentic coding (bash/interpreter tool), and virtually every production agent deployed today.

The Orchestrator-Subagent pattern is the primary building block of multi-agent systems. One agent (the orchestrator) receives a complex goal, decomposes it into subtasks, delegates each to a specialist subagent optimised for that task, and synthesises the results. The orchestrator uses a capable model for planning and synthesis while workers use cheaper, task-specific models — cutting costs 40–60% versus using a single large model for everything.

Anthropic’s “Building Effective Agents” (December 2024) names Orchestrator-Subagent as one of the two top-tier multi-agent architectures. It excels for cross-functional workflows: a research orchestrator delegates to a web-search agent, a document-analysis agent, and a citation-formatting agent simultaneously, then merges their outputs into a unified report.

Primary failure mode: context accumulation — the orchestrator accumulates context from every worker and at 4+ workers frequently exceeds context window limits. Mitigation: workers return structured summaries rather than raw outputs, and the orchestrator maintains a distilled state rather than the full message history.

The Supervisor pattern adds a quality-control layer on top of the Orchestrator-Subagent architecture. The supervisor is not just a coordinator — it actively monitors each subagent’s outputs, checks them against quality criteria, routes work to the appropriate agent based on the current context, and rejects or reroutes outputs that fail to meet the bar before they propagate downstream.

LangGraph’s supervisor-worker subgraph pattern is the canonical implementation: the supervisor node receives each worker’s output, applies a routing function (pass to next step, reject and retry, escalate to human review), and directs traffic accordingly. This makes the supervisor the enforcement point for SLAs, safety policies, and compliance requirements in production agentic pipelines.

The Parallel Fan-Out / Fan-In pattern maximises throughput by dispatching independent subtasks to multiple agents concurrently rather than sequentially. All agents work simultaneously (fan-out); a merger agent collects and synthesises all results once they complete (fan-in). Total latency approaches that of the slowest single agent rather than the sum of all agents.

Typical applications: running the same prompt at different temperatures and selecting the best response (speculative sampling); processing different document sections in parallel and merging into a summary; simultaneously calling multiple data sources and combining their outputs. The pattern requires that subtasks be genuinely independent — any dependency between tasks forces sequential execution and defeats the pattern’s purpose.

MapReduce adapts the classic distributed computing pattern to multi-agent systems. A mapper splits a large task into uniform chunks — pages of a document, rows of a dataset, items of a list — and assigns each chunk to a worker agent (the Map phase). Each worker processes its chunk independently and returns a structured result. A reducer agent aggregates all results into a single, coherent output (the Reduce phase).

MapReduce is the pattern of choice for tasks that exceed a single context window. Summarising a 500-page technical report: split into 50 ten-page chunks, process each in parallel, reduce into a structured executive summary. Analysing a month of customer support tickets: map each ticket through a sentiment classifier, reduce into aggregate statistics. The reducer phase requires careful design — a naive concatenation of 50 summaries is not useful; a structured aggregation with explicit merge logic is.

The Debate pattern pits multiple agents against each other in structured argumentation. Agents receive the same question and independently generate positions. They then challenge each other’s reasoning, identify logical gaps, and respond to criticism. A judge agent (or panel) evaluates the quality of arguments — not which position sounds more confident — and synthesises the most defensible answer.

Research from 2025–2026 reveals an intriguing finding: reasoning models spontaneously learn to emulate multi-agent debate during extended thinking, using internal personas for verification and backtracking. This suggests debate-style reasoning may be a natural emergent outcome of training for careful reasoning — not just an architectural choice. The pattern is 2–5x more expensive than single-agent generation but catches classes of errors that self-critique misses, especially errors that require an adversarial perspective.

Hierarchical Agents extends the Orchestrator-Subagent pattern to multiple levels of responsibility. A top-level orchestrator decomposes a strategic goal into major workstreams and assigns each to a mid-level orchestrator. Each mid-level orchestrator further decomposes its workstream into tasks for specialist worker agents. This mirrors how large human organisations structure complex projects — strategic, tactical, and operational layers with defined delegation protocols at each boundary.

The practical use case is enterprise-scale agentic systems where no single orchestrator can manage the full decomposition in its context window. A board-level strategic analysis agent might delegate to a financial analysis orchestrator, a competitive intelligence orchestrator, and a regulatory risk orchestrator — each of which manages its own team of specialists. The tradeoff is coordination overhead: every additional layer adds latency and cost.

The Sequential Pipeline is the simplest multi-agent topology: agents process work in a fixed linear order, each consuming the previous agent’s output as its input. The execution order is deterministic and defined at design time. Its simplicity is its strength: easy to understand, test, debug, and audit.

Microsoft’s Azure Architecture Center documents a law firm using a four-stage sequential pipeline for contract generation: template selection → clause customisation → compliance review → risk assessment. Each stage is handled by a dedicated agent optimised for that specific task. Error propagation is the primary risk: a mistake in stage 2 corrupts stages 3 and 4 with no recovery path. Add validation gates between pipeline stages for production deployments.

The Evaluator-Optimizer pattern formalises quality improvement into a closed loop between two agents. The generator agent produces a candidate output. The evaluator agent scores it against an explicit rubric — factuality, citation coverage, code-passes-tests, fluency, alignment with brief. If the score falls below the threshold, the critique flows back to the generator as structured feedback for the next iteration. The loop runs until the evaluator passes the candidate or a maximum iteration count is reached.

Named by Anthropic’s “Building Effective Agents” (Schluntz, December 2024) as one of the two top-tier multi-agent shapes, the pattern’s structural requirement is that quality criteria must be made explicit. An evaluator asked to “review this” without a rubric is just running Reflection under a different name. The evaluator works best when given concrete, binary-checkable criteria: “does the code pass the test suite?”, “are all statistical claims supported by a citation?”, “is the response under 200 words?”

The Critic-Actor pattern is closely related to Evaluator-Optimizer but with a crucial distinction: the critic’s role is to provide structured, actionable feedback — not just a pass/fail score. The actor uses this detailed critique to make targeted revisions, rather than generating a completely new response from scratch. This preserves what was good in the previous version while fixing what was not.

MIT research (Gao et al., 2025) applied a Planner-Actor-Critic framework to 3D modelling, demonstrating that critic-guided reflection with human supervisory input reduced modelling errors significantly versus direct single-prompt execution. The key design insight: the critic should be prompted with specific evaluation criteria rather than open-ended “find problems” instructions, and should return structured JSON critique (problem, location, suggested fix) rather than prose commentary that the actor must interpret.

The Self-Healing pattern gives an agent the ability to recover from failures autonomously. On encountering an error — a failed tool call, an invalid schema, a timeout, an unexpected API response — the agent does not simply propagate the error. It classifies the failure type, selects an appropriate recovery strategy, and retries with corrections: reformulating the query, switching to a fallback model, reducing the scope of the operation, or escalating to a human after a defined retry limit.

Self-healing is particularly valuable in long-horizon agentic tasks where transient failures — network timeouts, rate limit hits, temporary service unavailability — would otherwise abort multi-hour workflows. Neural-symbolic verification systems for cloud healing (2026) demonstrate that agents that can verify their own recovery plans against a world model before re-execution significantly outperform those that blindly retry with the same failed approach.

Human-in-the-Loop (HITL) is the designed boundary between what an AI agent may do autonomously and what requires a human decision. It is distinct from evaluation (which measures quality offline) and observability (which records what happened). HITL is the enforcement layer — it stops a consequential or irreversible action before it executes, rather than reporting on it after the fact.

A complete HITL design covers four dimensions: when to escalate (triggers — action type, confidence score, data sensitivity, irreversibility); how to escalate (sync for time-sensitive decisions, async for non-blocking approvals); what to send the human (a context package: the proposed action, the agent’s reasoning, relevant retrieved evidence, and suggested alternatives); and governance rules that classify which action types are always gated regardless of confidence.

LangGraph’s interrupt primitive, AWS Bedrock AgentCore (October 2025), and Vertex AI Agent Development Kit all support pausing agent execution, persisting state to a checkpoint store, and resuming cleanly after human input — without re-running from the start. Under the EU AI Act, HITL is not optional for high-risk AI systems in healthcare, legal services, finance, and critical infrastructure. It is a legal requirement.