Book a demo: +91-8956730400 Mon–Sat, 10 am–7 pm · Nashik

Single Agent vs Multi-Agent: When to Fold Subagents Into One Loop

Anthropic now advises many teams to fold multi-agent setups into one agent loop. What it found, when subagents still make sense, and how to fold safely.

Illustration contrasting many tangled agent nodes with one agent in a neat loop beside a toolbox

Should you build one AI agent or a team of agents? In single agent vs multi-agent design, Anthropic's guidance from 22 October 2026 is clear: start with one agent loop that loads skills and tools as it needs them, and split work into subagents only when you can measure a problem that splitting fixes. In its tests, a single agent with skills often beat both a one-big-prompt design and a subagent design on quality, and often at lower cost and latency per task.

That reverses the advice many teams followed through 2025, when an "orchestrator plus specialists" setup was the default picture of a serious agent. This report looks at what Anthropic found, where multi-agent designs lose time and quality, when they still earn their place, and how to fold an existing system back into one loop without breaking it.

What Anthropic published, and why it matters now

The article, "When to fold subagents into your main agent loop" by Diane Sarkis, argues that using fewer subagents, with context and tools disclosed progressively, can improve quality while cutting cost and latency.

It gives a few hard numbers. One customer's evaluation found a single agent loop ran roughly 2x faster than its multi-agent harness. Tool choice "tends to degrade" once a system prompt holds more than 30 to 50 tool definitions. And the article says newer models, starting with Opus 4.5, can manage far more within one loop than earlier ones could.

The timing fits a wider shift. The same week, the Agentic AI Foundation took in Anthropic's Agent Skills as an open format (VMblog, 22 October), which means the "skills loaded on demand" pattern is becoming a shared standard.

Two ways to build the same agent

Take a support agent for a distributor: it answers order status questions, checks invoices, raises returns and escalates complaints. There are two common designs.

Multi-agent design compared with a single agent loop Left: an orchestrator agent routes each request to one of four specialist subagents for orders, invoices, returns and complaints, with a handoff at each step. Right: one agent loop that loads the orders, invoices, returns or complaints skill only when needed, and calls a small set of data tools. Same job, two designs Orchestrator plus subagents Orchestrator Orders Invoices Returns Complaints A handoff at every step: context is summarised, passed on, and partly lost. One loop with skills One agent Orders skill Invoices skill Returns skill Complaints Skills load only when needed. One context, 4 or 5 thin data tools.
On the left, every request crosses a handoff. On the right, the agent keeps one context and pulls in instructions as it needs them.

The multi-agent version looks tidy on a whiteboard. Each specialist has a short prompt and a few tools, and the orchestrator decides who handles what.

The single-loop version keeps one agent in charge. Each area (orders, invoices, returns) becomes a skill: a folder of instructions and scripts the agent reads only when the task needs it. Data access becomes a small set of tools. Anthropic's article describes one customer-facing agent with about a dozen specialist subagents, where, by its estimate, 4 to 5 thin data tools with one system prompt and firm output guardrails would have covered most of the use case.

Where multi-agent systems lose time and quality

Most of the problems sit in the handoffs between agents.

Every handoff is a summary

When the orchestrator passes a task to a subagent, it passes a description, not its whole context. If the customer said earlier "this is the third time I'm asking", the returns subagent may never see it. The answer comes back technically right and tone-deaf.

Every hop adds model calls

An orchestrator call, a subagent call, a result back, often a check. Each hop adds waiting time, which fits the 2x runtime gap in Anthropic's example. On a voice agent, callers hear every pause, as our breakdown of where voice agent latency goes shows.

Routing becomes its own failure point

With many specialists, the orchestrator has to pick correctly every time. A wrong route fails quietly: the invoices agent gets a returns question and answers the part it understands.

Nobody owns the whole behaviour

Anthropic recommends that one small central team own the system prompt and end-to-end quality. In multi-agent builds, each specialist often gets its own owner, and nobody tests the full conversation.

When subagents still make sense

The article is not against subagents. It lists three conditions where they are worth keeping:

  1. A single loop shows measurable degradation from context bloat.
  2. Several tasks need to run in parallel, each with a fresh context that can be thrown away afterwards.
  3. One agent struggles to pick the right tools, or the system prompt has conflicting instructions.

It also says subagents work well for verification, parallel work and modular permissioning. That last one matters for business systems. If one part of the job can move money, it can sit in a separate agent with its own narrow permissions, a pattern we covered in how to set AI agent permissions safely.

Should this be a separate subagent? Decision tree. If the work needs to run in parallel with a fresh context, use a subagent. If not, and it needs narrower permissions such as moving money, use a subagent. If not, and one loop shows measured problems with context or tool choice, use a subagent. Otherwise make it a skill inside the main loop. Should this be a separate subagent? Must it run in parallel, fresh context? Does it need narrower permissions? Measured context or tool-choice issues? Keep it asa subagent yes yes yes no no Make it a skill
If none of the three questions gets a yes, the work belongs inside the main loop as a skill.

How to fold a multi-agent system back into one loop

Anthropic's article gives a five-step process, and ships a single-agent-loop-kit on GitHub with a guided workflow and a demo on a mock system. In plain terms:

Five steps to fold subagents into one loop Step 1 build a small end-to-end eval. Step 2 merge specialists that chain or share data. Step 3 call remaining subagents as tools. Step 4 fold one subagent at a time and compare. Step 5 run each eval task more than once and decide. Folding, one step at a time 1. Buildan evalfirst 2. Mergechainedspecialists 3. Call therest astools 4. Fold oneat a time,compare 5. Run eachtask twice+,then decide Prompts become skills, API calls become MCP tools. A change that passes once can still fail on the next run.
Anthropic's folding process: measure first, merge what already belongs together, and change one piece at a time.

Step 1: Build a small end-to-end eval before touching anything

Grade final answers against a rubric. The article says even 10 golden examples are enough to start. Cover every chain of agents that runs together in production and every rule the agent must not break.

Step 2: Merge specialists that already belong together

Specialists that chain on each other's output, touch the same data, or are often called together are the first to merge. In the support example, orders and returns read the same order records, so they go first.

Step 3: Call the remaining subagents as tools

Instead of handing the whole conversation to a subagent, the main agent calls it like a function and gets a result back. The article keeps full handoffs only for a subagent that must talk to the user directly.

Step 4: Fold one subagent at a time

Turn its prompt into a skill and its API calls into MCP tools. Compare eval results with and without it, check which tasks flipped from pass to fail, and only then decide whether to keep it.

Step 5: Run every task more than once

This is the step teams skip. In the article's sample support agent, a folded change broke a process in one run out of two. A single green test run would have hidden that.

The other direction: fixed procedures instead of free choice

Not every vendor is betting on one free-thinking agent. On 21 October, Kognitos launched "AI Employees" for finance and banking with 61 roles backed by 515 standard operating procedures, plus an agent called Quill that drafts new procedures for a person to approve (Kognitos launch announcement). It is in preview for Kognitos customers.

Kognitos frames its approach around an agent that follows the same approved procedure every time, instead of deciding each step on the fly. For finance work that has a practical benefit: when an auditor asks why an invoice was paid, there is a written procedure to point to.

The two approaches agree on the main point. Fewer moving parts, written procedures and checks you can audit matter more than the number of agents. For an invoice or payment process, I would want the procedure written down and approved by a person, whichever architecture runs it.

Decision table: one loop or several agents?

SituationStart withWhy
Support or sales agent answering one customer at a timeOne loop with skillsOne context keeps the full conversation; fewer calls means faster replies
Voice agent on phone callsOne loop with skillsEvery extra model hop adds a pause the caller hears
Agent with more than 30 to 50 toolsGroup tools into skills first; split only if tool choice is still poorAnthropic says tool choice tends to degrade past that range
Research across many sources at onceParallel subagentsEach search gets a fresh context that is thrown away afterwards
Any step that moves money or deletes dataSeparate subagent with narrow permissions, plus human approvalLimits what a mistake or a bad instruction can reach
Checking another agent's outputA separate verifierAnthropic lists verification as a good use of subagents
Existing multi-agent system that works but is slow or costlyEval first, then fold one subagent at a timeYou keep what works and measure every change

Questions to ask before you buy or build an agent

  • How many agents does this system run, and why is each one separate?
  • Which steps can move money, send messages or delete records, and who approves them?
  • Is there an end-to-end eval, and how many times is each test run?
  • What is the reply time for a typical request, and how many model calls does it take?
  • Who owns the whole system prompt?

If a vendor can't answer the first question in one sentence, the design is probably more complicated than the job. Our AI agent development page explains how we scope agents, or book a free 30-minute audit.

Architecture matters less than picking the right first job for an agent. Next Monday we go back to basics with a step-by-step guide to automating customer onboarding in a small business: the welcome message, the documents, the first-week check-in, and where a person still has to step in.

Want to know what you could automate?

Book a free 30-minute automation audit. We'll look at one process with you and tell you honestly whether automating it is worth it. See how we work or browse our services.

Book a free audit

Get posts like this in your inbox once a week. Subscribe to NXT Weekly.

Keep reading

All posts