Anthropic Publishes an AI Agent Architecture Guide: Ask Three Questions Before Deciding Whether to Go Multi-Agent
Multi-agent systems can boost performance by 90.2%, but they also cost 10-15x more in tokens — this three-question framework helps you decide whether it's worth it before you build.
- Anthropic published an enterprise-grade AI agent architecture guide, drawing on real deployments from customers like Coinbase, Intercom, and Thomson Reuters to lay out architecture patterns and a selection method.
- The guide covers six core architectures: single agent, hierarchical (supervisor), collaborative, sequential workflow, parallel workflow, and evaluator-optimizer workflow.
- Anthropic's internal research shows that for complex tasks requiring simultaneous exploration of multiple independent paths, multi-agent systems outperform single agents by 90.2% — but consume 10-15x more tokens.
- The guide offers a three-question decision framework (how much control you need, how many domains the problem spans, what your resource budget is) to help you pick the right architecture instead of defaulting to the most complex one.
- The core method is "start simple, evolve gradually": validate value with a single agent first, then upgrade based on business needs and data feedback — rather than building a complex system from day one.
An enterprise agent architecture handbook from Anthropic
Anthropic recently published an enterprise-facing AI agent architecture guide, compiling real deployment cases from customers like Coinbase, Intercom, and Thomson Reuters into six architecture patterns and a selection decision framework.
The white paper opens with a line that states its position outright: generative AI answers questions, AI agents solve problems. And what this handbook sets out to answer is the next, more practical question — for a given business, should you run one AI agent solo, or build out a whole multi-agent system? It breaks that choice down into an actionable decision framework, backing each architecture with quantified data from real customers.
Why it's worth reading: the guide surfaces one key trade-off — for complex tasks that require exploring multiple independent directions at once, multi-agent systems outperform single agents by 90.2%; but they also consume 10-15x more tokens than a single agent. This one trade-off is the foundation for every architecture decision in the entire guide.
Let's get one thing straight first: AI agents and ordinary automation scripts work very differently. Traditional automation requires every step to be hard-coded in advance — the process follows the script step by step, and it gets stuck the moment it hits a situation nobody anticipated. An agent's approach is to evaluate the task, pick the right tool, try an approach, check whether the result is good, and adjust its strategy — running that loop until the job gets done.
Every step has to be pre-written. The process is fixed and traceable, but it only ever walks the path laid out in advance — and breaks the moment it hits an edge case.
Given a task, it plans on its own: reads the problem, checks account history, searches the knowledge base, drafts a reply, and loops in a human when needed — adjusting its strategy the whole way based on intermediate results.
The guide opens with a batch of customer results, meant to show what these systems have delivered in real production environments.
These four figures aren't about scale — they're about coverage: customer support, security operations, fraud review, and cross-industry resolution rates — four completely different jobs, all held up by agents in production. What they prove is "this is worth investing in," not "which architecture to pick." The guide also gives a more relatable, day-to-day example: a retail bank used an agent to process credit risk memos. What used to take relationship managers weeks of manually cross-checking ten data sources now delivers a 20% to 60% productivity gain, cutting credit turnaround time by 30%. These numbers establish a premise — agents are worth investing in — but which architecture you use to build one is what this guide is really here to teach. It covers six architectures in total, which really fall into three families: ones where the AI decides for itself (single agent, hierarchical/supervisor, collaborative), ones where the process is pre-scripted by humans (sequential and parallel workflows), plus one dedicated to quality control (evaluator-optimizer). Let's go through them from simplest to most complex.
Step one: check whether a single agent is enough
The first principle the guide keeps hammering is "start simple." Don't jump straight to a complex system — first check whether a single agent can solve the problem. It's cheaper, easier to debug, and its metrics map more cleanly to business outcomes.
A single-agent system is just one AI agent running a continuous loop: sense the environment, decide the next step, take action, and repeat until the task is done or it hits a stop condition like "pause for human review." A few components hold this together at its core.
Two of the three components in the diagram are specific terms worth explaining up front.
A standard interface that lets an agent connect to external systems — databases, web search, internal tools. It's what lets an agent actually go query data and operate tools, rather than just chat. Think of it as a universal adapter for AI: whether it's plugging into a database or a search engine, the interface is standardized, so you don't need custom integration code for every connection.
Domain expertise, standard procedures, and tool usage packaged into a module that an agent can call on demand, instead of cramming all domain knowledge into the prompt. Think of it as giving the agent a set of specialized toolboxes — pull out the legal toolbox for legal questions, swap in the finance one for finance questions — one agent doesn't need to carry every domain in its head at once.
Good fit: open-ended problems where the path forward isn't clear at the start — you don't know how many steps it'll take or what obstacles you'll hit — and you want the agent to figure it out and adjust as it goes.
Not a fit: scenarios that demand a perfect answer on the first try. A single agent struggles here — either add specialized Skills to boost accuracy, or only then consider going multi-agent. Before upgrading, ask yourself: would adding Skills to the single agent already be enough?