What are agentic design patterns?
An agentic design pattern is a named structure for how a language model, its tools and its control flow fit together to finish multi-step work. Like classic software patterns, they give teams shared vocabulary: "make it an evaluator loop" says more than a page of prose. Unlike classic patterns, each one changes the token bill, the latency and how hard a failure is to trace.
Four catalogs dominate what teams read, and they overlap more than their naming suggests:
| Source | Patterns | Framing |
|---|---|---|
| Andrew Ng (DeepLearning.AI) | Reflection, tool use, planning, multi-agent collaboration | Capabilities an agent adds on top of a single model call |
| Anthropic, "Building effective agents" (Dec 2024) | Augmented LLM; prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer; autonomous agents | Control flow, ordered from most to least predictable |
| Antonio Gulli, Agentic Design Patterns (Springer, Oct 2025) | 21 patterns, one per chapter, including prompt chaining, tool use, multi-agent collaboration and self-correction | A full catalog for implementers |
| Microsoft, AI Agents for Beginners (lesson 3) | Principles across space, time and core: transparency, user control, memory of the past | How agents should behave toward the people using them |
Ng's four are capabilities. Anthropic's are control-flow shapes. Gulli's are an implementer's reference. Most production systems combine several: a router in front, tool use inside each branch, an evaluator before output.
What does each pattern cost, and how does it fail?
| Pattern | What it does | Use when | Cost | Typical failure |
|---|---|---|---|---|
| Prompt chaining | Fixed sequence of calls; each step processes the last, with checks between | The task splits cleanly into known steps | Low; latency adds per step | An early step's error propagates silently |
| Routing | Classify the input, send it to a specialized prompt or model | Input types differ enough to need different handling | Low; one extra call | Misclassification sends work down the wrong path |
| Parallelization | Split into independent subtasks, or run the same task several times and vote | Speed matters, or several views raise confidence | Tokens multiply; wall-clock drops | Merging partial results loses context |
| Reflection / evaluator-optimizer | One pass generates, another critiques, repeat until a bar is met | Clear quality criteria and iteration measurably helps | Two or more calls per round | A critic with the same objective agrees with itself |
| Tool use | Model chooses functions, APIs or searches to call | The answer depends on live data or actions | Per tool call; integration work | Badly described tools get misused |
| Planning | Model decomposes the goal into subtasks before acting | Multi-step goals whose steps vary per request | Planning call plus execution | A wrong plan is executed faithfully |
| Orchestrator-workers | A lead model decomposes dynamically, delegates, synthesizes | Subtasks cannot be predicted in advance | High; many calls, long contexts | The decomposition itself is a model output |
| Multi-agent collaboration | Several specialized agents with roles exchange work | Distinct expertise or tool sets per role | Highest; coordination overhead | Agents talk past each other; errors compound |
| Autonomous agent | Model loops on tools and environment feedback until done | Open-ended problems with unknown step count | Unbounded without caps | Compounding errors; needs sandbox and stop conditions |
The pattern most often misapplied is reflection. A model asked to review its own answer with the same instructions tends to approve it. The pattern works when the critic has a different objective or different information from the generator: a test suite, a rubric, a retrieval step, or a separate model prompted to find faults. Our agentic workflows explainer covers the same point from the orchestration side.
Workflow or agent: which side of the line are you on?
Anthropic's Building effective agents draws the line that matters for architecture reviews. Workflows run models and tools through predefined code paths. Agents let the model decide its own process and tool use. The first five patterns in the table are workflows; orchestrators sit on the boundary; multi-agent systems and autonomous loops are agents.
The same piece gives the advice most teams skip: find the simplest solution that works, call the model API directly before adopting a framework, and invest in tool design as heavily as in prompts. Anthropic reports that requiring absolute file paths in a tool removed a whole class of errors for its SWE-bench agent. Tool descriptions are the interface the model sees, and a confusing one produces confused behavior.
How should you choose a pattern?
The decision rule: climb one rung at a time, and only when an eval shows the current rung hitting a ceiling. Andrew Ng makes the same argument from the other direction: the best predictor of shipping a good agent is a disciplined process for evals and error analysis, not the choice of architecture (The Batch, October 2025).
| Rung | Use | Move up when |
|---|---|---|
| 1 | Single call with retrieval and examples | Evals show a quality ceiling a single call cannot pass |
| 2 | Chaining or routing | Steps vary per input in ways code cannot enumerate |
| 3 | Tool use, reflection, planning | Subtasks are unknown until runtime and need delegation |
| 4 | Orchestrator-workers or multi-agent | Step count is truly open-ended and a sandbox, budget cap and stop rule exist |
| 5 | Autonomous agent loop | Top of the ladder; keep a human checkpoint on irreversible actions |
Two signals say you climbed too far. Cost per task varies by an order of magnitude between similar inputs, which means the model is improvising the decomposition. And nobody can explain a failure from the trace, which means the system has more moving parts than your observability covers. Both are reasons to step back down a rung.
What about patterns for how agents treat users?
Microsoft's AI Agents for Beginners uses "agentic design" for a third thing: principles for agent behavior toward people. Agents should connect people rather than replace them, work in the background but step forward when relevant, use memory of past interactions, be transparent about uncertainty, and leave humans in control of turning them on and off with status always visible. Product teams building agent features should read it alongside the architecture catalogs. Teams looking for AI agents that do UI and brand design want our agentic design explainer instead.
Related questions
Frequently asked questions
What are agentic design patterns?
Agentic design patterns are reusable ways of structuring an AI system so a language model can carry out multi-step work: reflecting on its own output, calling tools, planning subtasks, routing inputs, running work in parallel, delegating to worker agents, looping with an evaluator, and coordinating several specialized agents. They play the role for agents that classic software design patterns play for object-oriented code.
What are the four agentic design patterns?
Andrew Ng's widely cited set is reflection (the agent critiques and improves its own output), tool use (it decides which functions or APIs to call), planning (it breaks a task into subtasks) and multi-agent collaboration (several specialized agents work together). He repeated them in The Batch in October 2025 alongside his Agentic AI course.
What is the difference between a workflow and an agent?
In Anthropic's definition, workflows orchestrate models and tools through predefined code paths, while agents let the model direct its own process and tool use. Workflows are more predictable and cheaper; agents handle open-ended problems where the number of steps cannot be known in advance, at higher cost and with compounding errors.
Is there a book on agentic design patterns?
Yes. Antonio Gulli's "Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems" was published by Springer in October 2025 and covers 21 patterns, one per chapter, including prompt chaining, tool use, multi-agent collaboration and self-correction.
Is agentic design the same as AI design agents?
No. Agentic design patterns are about building agents. AI design agents are products that do UI, product or brand design work, such as Claude Design, the Figma design agent or Google Stitch. CTAIO covers those in a separate explainer on agentic design.
Sources
- Anthropic, Building effective agents (19 December 2024).
- Andrew Ng, Check out our course on how to build AI agents, The Batch (8 October 2025).
- Antonio Gulli, Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems, Springer (October 2025).
- Microsoft, AI Agents for Beginners, lesson 3: agentic design patterns.