Anyone integrating AI agents into development or business processes faces an architectural decision early on: should a swarm of specialised subagents divide the work among themselves, or should a single main agent take on the task and load the information it needs as required? Anthropic, the provider of the Claude models, now recommends the second option.
The recommendation is notable because multi-agent setups have been regarded in recent months as the obvious answer to complex tasks. The idea behind it: each subagent gets a narrow area of responsibility, its own system prompt and its own tools, while a superordinate agent distributes and collects. In practice, however, this creates a distributed system with all the familiar side effects.
What Anthropic recommends
Anthropic advises companies to abandon multi-agent architectures in favour of a single main agent that loads its context as needed. Context here means everything passed to the language model at runtime: instructions, documents, intermediate results, tool descriptions. Instead of distributing this knowledge across several specialised agents in advance, the one agent specifically retrieves what is needed for the current work step.
In a customer case described by Anthropic, the rebuild doubled the speed. For the migration, the company provides a migration kit on the GitHub development platform, i.e. a collection of templates and aids with which existing multi-agent setups can be converted into a single-agent structure.
Why many agents are often more expensive than expected
The appeal of subagents lies in the division of labour. The price for this is coordination. Every handover between agents generates additional model calls, additional waiting time and additional points at which information can be lost or distorted. What a subagent considers important must be summarised in text form for the next one – and precisely this intermediate step is error-prone.
On top of that comes observability. If a result is incorrect, it must be traceable which step was responsible. With a chain of several agents, each with its own memory, this tracing is considerably more complex than with a process that takes place in a single context. For operations, this means more logging, more tests and more need for explanation towards the business departments.
When a single agent is enough
A main agent with reloadable context is particularly suitable where tasks are varied but sequential: qualifying enquiries, evaluating documents, merging data from several systems, analysing and adapting code. What is decisive is less the number of agents than the quality of the tools available to the agent and the precision with which information is provided.
In practice, this means: clearly described interfaces, clean search functions on your own data sets and tools that deliver small, verifiable results. An agent that can specifically ask for more information does not need a second agent that permanently holds the same knowledge.
What this means for ongoing projects
For companies already working with agents, a sober stocktake is worthwhile. Helpful guiding questions are:
- Which subagents exist, and which task does each of them demonstrably fulfil on its own?
- How many model calls are spent on pure coordination rather than on substantive work?
- At which handover points do most errors occur in practice?
- Could the same process be mapped with one agent and better tools?
Anyone considering a simplification should treat it like any architecture change: with a defined benchmark. Without measuring runtime, cost per transaction and result quality before and after the rebuild, any statement about improvements remains a guess. The fact that a provider supplies a migration kit saves work on the mechanics, but not your own evaluation of the results.
Assessment
The recommendation is also an indication of how young the field still is: patterns that were recently regarded as standard are being relativised by the model provider itself. For decisions in companies, this argues for deliberately keeping agent architectures interchangeable and not burying business logic in the wiring between agents.
For web and software projects, this specifically means: the simplest architecture that supports the use case is usually also the one that can be operated, tested and explained. Instead of multiplying agents, it is worth investing in good interfaces, clean data access and traceable logging – these building blocks remain usable even if models and recommendations change again. And every simplification should be verified against measurable variables such as response time, cost per transaction and error rate, not against the number of components involved.