Anthropic says one AI agent often beats many agents

AI companies and developers have long built systems where several specialized AI agents work together on different tasks. Now Anthropic, the company behind Claude, says this way of organizing AI is often more complicated than it needs to be. Experience from business customers suggests that in many cases one agent with the right skills and tools can deliver better results, faster and at a lower cost.

In an article published on October 22, 2026, Anthropic describes a change in how the company recommends building AI agents. Instead of creating a separate agent for each task, it recommends checking whether one main agent can handle several tasks by bringing in the right knowledge and the right tools when they are needed.

The recommendation builds on experience from Anthropic's Applied AI team, which has compared different setups at several business customers. The results are interesting, but it is important to stress that these are Anthropic's own comparisons, not independent studies showing that one agent is always better.

In brief

• Fewer AI agents: Many tasks that used to be split between specialized agents can be handled by one main agent.
• Skills and tools: The agent gets access to expert knowledge, instructions and functions when it needs them, instead of having everything available all the time.
• More agents when needed: Large tasks, parallel work and independent checking can still make it sensible to use several agents.

Why have we built so many AI agents?

An AI agent is a system that uses an AI model to carry out tasks, make decisions along the way and use tools to reach a goal. Unlike an ordinary chatbot, which mainly answers questions, an agent can for example look up information, fetch data from other systems, update documents and follow up on the results.

When developers build these systems, it has been common to split the tasks between several agents. One agent looks up information, another analyzes the results, a third makes decisions and a fourth carries out the actions.

That can seem logical. After all, ordinary companies have different departments and employees, each with their own area of responsibility. But AI agents do not necessarily work best when they are organized the same way as people.

Anthropic points out that many companies have ended up with very complicated systems. Each department gets its own agent with its own instructions and tools. Then yet another agent is built to coordinate all the others. The result can be a large network of agents that spend a lot of time passing tasks and information back and forth.

The problem is not just that this takes time and costs money. It can also cause important information to get lost.

Picture a company that buys IT equipment

Let's use an IT retailer as an example. A customer orders 30 laptops and wants them delivered by Friday.

The company has an AI system with four agents. The first records the order. The second checks price and availability with the distributors. The third plans the delivery, while the fourth sends the customer an order confirmation.

Each agent does its part of the job and passes the result on to the next agent. But what happens if the distributor has the laptops in stock, while part of the order cannot be delivered until Monday?

The second agent may have spotted this, but if the information is summarized poorly when the task is passed on, the fourth agent risks confirming Friday delivery anyway.

This is an example of what Anthropic describes as a problem with handoffs between agents. Each agent has its own context window, which is the information the AI model has available when it carries out the task. When one agent sends its result to another, the information is often shortened or summarized.

The more handoffs there are, the more chances there are for details to disappear.

This does not mean that several agents always lead to mistakes, but it adds more places where mistakes can happen.

One agent that keeps the full picture

Anthropic's alternative is to let one main agent be responsible for the whole task.

In the IT retailer example, the agent could first take in the customer's order, then check prices and stock with the distributors, look into delivery options and finally write an order confirmation.

The difference is that the same agent keeps the information from the earlier steps. It knows why a particular distributor was chosen, which items are available, and why part of the delivery might be delayed.

The agent also does not have to follow a completely fixed plan. If it discovers that the items cannot be delivered in time, it can look into other distributors before it continues.

Anthropic calls this a single agent loop. It means the same AI agent works in a loop, a cycle it repeats step by step. It assesses what needs to be done, uses the tools it needs, checks the results and decides the next step. The process continues until the task is done or a limit set in advance is reached.

An important detail is that one agent can still carry out several technical operations at the same time. For example, it can send requests to three distributors in parallel, meaning at the same time, and handle the answers as they come back. There is no need to create three separate AI agents just to collect three prices.

But how can one agent know about purchasing, logistics, customer service and a range of other fields without getting overloaded?

This is where skills come in.

Skills give the agent new abilities without creating new agents

A skill is a collection of instructions, expert rules and sometimes ready-made programs that tell an AI agent how to carry out a particular type of task.

A purchasing skill could for example include rules for how to compare distributors, which terms to check and how to calculate the total price. A logistics skill could describe how to check delivery times and how to handle delays.

These are not independent AI agents. They are knowledge and procedures the main agent can use when they are relevant.

To understand the difference, we can use photography as an example.

A professional photographer can handle the whole process, from planning and shooting to picking images, editing and final delivery. The photographer does not need to be five different people to do these tasks.

The photographer does, however, need different knowledge and equipment along the way. During the shoot, camera settings, light and composition matter. During image editing, other skills apply, for example color correction, retouching and preparing image files.

An AI agent can work in a similar way.

When the agent is planning a photo shoot, it can bring in a skill with routines for lighting, equipment and planning. When the images are being edited, it can use another skill with instructions for retouching, color work and export.

The image editing itself can be done with scripts or tools that control an image editing program. Here the difference matters. The skill describes how the task should be done, while the tool makes it possible to carry out specific actions.

The same main agent can coordinate the process without starting a new AI agent for each step.

The agent gets only the information it needs

A central part of Anthropic's recommendation is something it calls progressive disclosure, which simply means that information is made available bit by bit, as it is needed.

Imagine a photographer with a large digital library of user manuals, editing routines, camera setups and export settings. It would be impractical to read through the whole library before every single shoot.

It is far more efficient to have an overview of what the library contains, and then open the documents that are relevant to the task.

The same principle applies to the AI agent.

Instead of giving the model hundreds of pages of instructions from the start, it can get short descriptions of the available skills and tools. The full instructions are only fetched when the agent needs them.

This matters because AI models have a limited amount of information they can handle at once, called the context window. The more irrelevant information fills this window, the harder it can be to keep track.

That is why Anthropic does not recommend replacing many agents with one huge instruction that contains absolutely everything. The point is to combine one main agent with a tidy system for bringing in the right knowledge at the right time.

Better quality and lower costs, according to Anthropic

Anthropic says it has compared different ways of organizing AI agents in several business projects.

In these comparisons, one main agent with skills often gave better results than both systems with many specialized agents and setups where all the instructions were gathered in one large message to the model.

The company also describes a case where one business's single-agent setup completed the tasks about twice as fast as the system with several agents.

Another example is about a company that had about twelve specialized agents in its customer service. The different agents made it hard to keep a consistent way of communicating with customers. On top of that, the cooperation between the agents caused extra waiting time.

These are relevant observations, but Anthropic does not publish enough detail about all the comparisons for us to say how much faster, cheaper or better this kind of design will be in general.

There is also no guarantee that one agent always uses fewer resources. If the main agent has to handle huge amounts of information, or keeps repeating the same lookups, the benefits can disappear.

So the right choice depends on which task needs to be solved, and how the system is built.

When is it still better to use several AI agents?

Anthropic stresses that subagents are still useful. A subagent is a separate AI agent that gets a limited task from a main agent, and that can work with its own instructions and its own information.

There are three situations in particular where this setup can be better.

The first is when a task needs so much information that the main agent loses track. A subagent can then look into a limited part of the problem and return a result without the main agent having to process all the material itself.

The second is when several large tasks can be done independently of each other. Imagine a purchasing department that needs to look into ten new suppliers in different countries. Separate agents can each do a thorough review at the same time, before a main agent compares the results.

The third situation is when the main agent has trouble choosing between many tools, or when different instructions conflict with each other. Then it can be better to split off parts of the responsibility.

Independent quality checking can also be a good reason to use a separate agent. An agent that has written a report will not necessarily spot all the weaknesses in its own work. Another agent can check the facts without being influenced by the whole process that led to the conclusion.

What matters is whether the tasks are actually solved better separately, not whether it seems natural to give each task its own agent.

Fewer agents does not mean fewer safety rules

Giving one agent more responsibility does not mean it should get unlimited access to do whatever it wants.

In a purchasing system, for example, the agent could be allowed to fetch prices, compare suppliers and suggest an order. But if it is going to make a purchase of 100,000 Norwegian kroner, the system can require approval from a human.

Limits like these should be enforced by the software that carries out the action, not just written as an instruction to the AI model.

The same goes for access to customer data, financial information and other sensitive systems. The agent should only be able to take actions it actually has permission to take.

That is why Anthropic recommends keeping fixed technical controls for approvals, access rights and resource use, among other things, even when more tasks are gathered in one agent.

How do you find out which setup is best?

Anthropic's most important practical recommendation is to test before rebuilding an existing system.

The company suggests starting with a small set of about ten representative test tasks. These should show how the system works in real situations, including difficult cases and rules that must never be broken.

For a purchasing system, the tests could for example include an ordinary order, an item that is sold out, a supplier with a longer delivery time, different exchange rates and an order that needs approval.

First you run the tests on the existing setup. Then you replace one subagent with a skill and the tools it needs, and run the same tests again.

You do not just compare how well the agent answers, but also whether it actually completes the tasks correctly, how long it takes and what it costs.

Anthropic also describes a case where this kind of simplification made the customer service agent faster, but at the same time introduced a mistake. The agent answered a question about an order without checking the expected delivery date. This shows why the tests must check the whole task, not just whether the answer sounds convincing.

To help developers with this process, Anthropic has published an open migration kit called the Single Agent Loop Kit. It contains aids for examining existing agent setups, creating tests and comparing setups before and after the changes.

For now, the kit is a reference setup with limited practical testing, not a finished system for everyday use that fits everyone.

A change in how we should think when we build with AI

The most interesting thing about Anthropic's recommendation may not be the drop in the number of agents itself, but how increasingly capable AI models are changing the way we build systems.

In the past, it could be necessary to split many tasks into separate processes, with carefully defined rules for which agent should do what. As the models get better at planning, using tools and handling several steps in a task, some of this splitting can become unnecessary.

This does not mean that one AI agent should do everything, or that skills replace the need for programming, databases and traditional systems. On the contrary, the line between the AI model's judgments and the software's specific functions becomes more important.

The AI agent can decide what should be done next. Skills can describe how different tasks should be carried out. Ordinary program code and tools can make sure that calculations, data processing, approvals and other actions are carried out in a controlled way.

For developers, this means that the number of AI agents is not necessarily what decides how advanced a system is. A setup with one well-organized agent can be more flexible than a complicated network of specialized agents.

So Anthropic's recommendation is not to stop building systems with several agents. It is to stop assuming that more agents automatically make a better system.

Before you build yet another specialized AI agent, check whether the existing agent could get a new skill or a new tool instead. And before you decide, test both setups against the same tasks.

Key takeaways

• Every handoff between agents can lose details, and one agent that keeps the full picture can avoid that.
• Skills give the agent expert knowledge when needed, so it does not have to carry everything in the context window all the time.
• Several agents still pay off for large amounts of information, independent tasks and independent checking.
• Approvals and access rights should be enforced by the software, not just written in the instructions.
• Test first. Run about ten representative tasks on today's setup and on the simplified one, and compare quality, time and cost. The results in the article are Anthropic's own and not independently confirmed.

The examples from purchasing, logistics and photography are made-up illustrations to explain the principles, not documented customer cases from Anthropic.

Sources and further reading