Design Patterns

When building agents, the first instinct is usually a single agent with all available tools. This works well for simple, focused tasks. It fails predictably for complex ones: the context window fills with irrelevant tool history, the agent confuses tools meant for different sub-tasks, and failure in one part blocks everything else. Patterns are the vocabulary for recognising these failure modes early and choosing an architecture that avoids them.

Six patterns cover the vast majority of agent use cases. Each pattern has a specific failure mode it avoids, a latency and cost profile, and a set of conditions under which it outperforms the alternatives. Selecting the right pattern for a task is a consequential design decision made at the start of a project, not an optimisation applied after the agent is already in production.

Single agent. One LLM, a set of tools, a loop. The simplest and most underused pattern. Appropriate for well-defined tasks with fewer than ten tools, short to medium conversation length, and a single domain. Avoid when the tool set is large enough to cause selection confusion or when tasks can be parallelised for significant latency savings.

Router. A lightweight routing agent reads each incoming request and delegates it to the most appropriate specialised agent. Use when there are multiple distinct task types with different tool sets, and when using cheaper or faster models for simple routing decisions saves cost. Keep the routing categories simple: a router that classifies into ten categories is likely solving the wrong problem.

Supervisor. A supervisor agent orchestrates multiple sub-agents, assigning tasks, collecting results, and synthesising a final output. Use when a task can be broken into parallel sub-tasks and a synthesised output is needed. Note that a supervisor synthesises what its workers report. If a worker hallucinates, the supervisor may incorporate that error into the final output. Validation must be built into worker tool calls, not only into the supervisor's synthesis step.

Map-Reduce. A large collection of inputs is processed by mapping an operation across each item (potentially in parallel using async execution), then reducing the results into a single output. Use for processing many similar items such as documents, reviews, or records. Cheap map-phase models and async execution make this pattern highly cost-effective for batch workloads.

Chain. Output from one step is the input to the next. Steps run sequentially; each transforms the data before passing it forward. Use for pipeline tasks with distinct transformations and quality gates between steps. Each step can be independently tested and optimised. Failures are localised to a specific step, making debugging straightforward.

Reflection. The agent generates an initial response, critiques its own output against the goal, and revises before returning the final answer. Use for quality-critical tasks where accuracy matters more than speed. The risk: reflection adds latency and cost, and the agent may miss the same errors it made initially since the same reasoning patterns are applied to both generation and critique.

The pattern selection decision follows a consistent logic. Start with the simplest option that satisfies the requirements. Add complexity only when there is a specific, measurable problem: context overflow, tool confusion, the need for parallelism, or quality improvement that justifies added latency.

For tasks that are simple and focused on one domain, single agent is almost always the right starting point. For tasks with multiple distinct types coming through a single entry point, router pattern keeps tool sets clean per agent. For tasks that decompose into parallel sub-tasks with a synthesised output, supervisor pattern enables concurrent work. For processing large batches of similar items, map-reduce with async execution processes them concurrently at low per-item cost. For sequential transformation pipelines with discrete stages, chain pattern localises failures and enables per-step optimisation. For quality-critical output where a second pass consistently improves results, reflection pattern adds a self-review cycle.