Subagents vs skills: when to use subagents, and when one Claude agent does the job better

Use subagents only when one agent loop is measurably slowed down by too much context, when several jobs need to run in parallel in fresh context windows, or when a single agent keeps picking the wrong tool or is given clashing instructions. For almost everything else, Anthropic now advises folding subagents into one main agent loop that loads skills and tools only when it needs them.

The advice, published by Anthropic on October 22, 2026, comes from its Applied AI team’s work with large companies building agents on Claude Platform. In its comparisons across several enterprise deployments, a single agent with skills frequently beat both a one-prompt-for-everything design and a subagent design on quality, and often cost less and ran faster per task. One customer found a single agent loop ran roughly twice as fast as its multi-agent setup.

Subagents vs skills: what’s the difference?

A subagent is a separate agent with its own context window, tools and instructions, run by a coordinator that hands it work and gets a result back. A skill is a package of instructions the main agent loads only when a task calls for it, so the knowledge lands in the same context window as everything else. The jobs a specialist subagent used to do can go to three other places instead:

The difference that matters most is context. An agent that has seen every earlier step can connect them, which Anthropic says gives richer answers than summaries handed back by subagents. Skills are also an open format now: Anthropic handed Agent Skills to the Linux Foundation on October 22, the same day as this advice.

When to use subagents

Anthropic still uses subagents in its own agents, including its multi-agent research system, and says they are good at verification, parallel work and keeping permissions separate. It lists three conditions where a subagent earns its place:

• Context bloat: a single agent loop shows measurable drops in performance because its context is too full.
• Parallel work: several tasks need tackling at once in fresh context windows that can be thrown away when each is done.
• Tool or instruction trouble: one agent struggles to choose the right tools, or its system prompt contains conflicting instructions.

When you do split work up, divide it by context, not by problem type. Give each subagent a piece of work that needs little from the rest of the system and have it return a compact result. Good candidates are independent research paths, separate components with clean interfaces, and black-box verification. Split agents by problem type instead and they end up playing what Anthropic calls a “telephone game”, passing information back and forth and losing detail with each handoff. Start with the simplest multi-agent pattern that could work, such as a generator and verifier, or one orchestrator with subagents.

Single agent vs multi agent: signs you have too many subagents

The trap Anthropic describes is common in big companies: each team builds its own agent for its product, then a central platform team puts an orchestrator on top. The agent design ends up as a copy of the org chart. It names five problems that follow:

• Context management: someone has to decide what context passes between agents, and detail gets lost in the back and forth.
• Subagent sprawl: every team ships its own, until there are hundreds of overlapping subagents with no shared standards and no owner.
• The “Frankenprompt”: every team adds a sentence to the system prompt, leaving conflicting rules and no consistent voice.
• Local evals: each team tests only its own subtask, nobody maintains the whole set, and leaders make decisions on watered-down scores.
• Latency: every extra layer adds waiting time for the user.

One company’s customer-facing agent had a dozen specialist subagents, which made a consistent on-brand voice hard to keep and slowed replies. Anthropic says many proposed designs (an intent classifier, a fixed reasoning pipeline, user-segment buckets and an orchestrator on top) could be covered by one clear system prompt, four or five thin data tools and firm output guardrails.

What a single agent loop looks like

The design Anthropic suggests working towards is one model and one context window running an open-ended tool loop, with limits such as turn and cost budgets and write gates set in the harness around it. Each turn, the model asks for a batch of tool calls, the harness runs them in parallel and returns the raw results, and the same model decides what to do next: another batch, a question to the user, or an answer. The model writes its own plan on the first turn and revises it as results arrive, so the agent that makes the plan is the one carrying it out.

Two features stop that single loop drowning in context. Skills appear to the agent as short descriptions and load in full only when needed. Tool search does the same for tools: you mark tools with defer_loading: true and Claude searches for the ones it needs. Anthropic’s documentation says Claude’s ability to pick the right tool degrades once more than 30 to 50 tools are loaded, and that tool search typically cuts the space taken by tool definitions by over 85 percent, handling up to 10,000 deferred tools in a request. Anthropic advises grouping tools by what the user wants to do, not one tool per API.

Newer models are the other reason. Anthropic says models from Claude Opus 4.5 onwards can manage far more in one loop than most teams expect, and that it cut Claude Code’s system prompt for more advanced models by over 80 percent, partly by loading skills and tools progressively.

How to fold subagents into your main agent

Anthropic recommends getting there in stages, measuring each step:

1. Build an end-to-end eval first. Ten “golden” example tasks are enough to start. Grade the final answer against a rubric, and while an orchestrator remains, track whether it routed to the right subagent.
2. Merge subagents that always run together. If a large share of traffic is one specialist followed by another, or two touch the same data, combine them, starting with the most used.
3. Call the rest as tools. The main agent keeps the conversation and calls each subagent like a tool with a shared response format. This needs no rewrite and gives you a baseline score. Only hand the conversation over completely when a subagent has to talk to the user directly.
4. Fold one subagent at a time into skills and tools. Turn its prompts into a skill and its API calls into MCP tools, then compare scores with and without it.
5. Look at which tasks flipped, not just the total. Keep the subagent only if the folded version scores worse.

Anthropic’s own test shows why the last step matters. Folding one subagent into another in a sample support agent cut latency but broke a process that had been passing: the main agent held the order lookup tool and answered on its own, without asking the shipping specialist for the delivery date. The break showed up in only one run out of two, so run each task more than once and make sure the eval covers every chain of agents used in production and every rule the agent must not break.

Anthropic’s single-agent-loop-kit and /claude-api commands

Anthropic published a free single-agent-loop-kit on GitHub (Apache 2.0 licence) alongside the advice. It is a Claude Code skill that audits your system and gives each subagent a verdict: fold, merge, call as a tool, or keep. It then makes one change at a time, scoring each before and after. It includes a demo support desk with a router and six subagents that runs offline on a stand-in model in about ten minutes, with no API key. Anthropic labels it a reference implementation that it does not maintain, so fork it rather than wait for fixes.

The kit leans on four new Claude Code commands from the Claude API skill:

• /claude-api build-eval builds a first end-to-end eval, or the small evals each team ships with its skill.
• /claude-api prompt-audit flags instructions written for older models that now make an agent slower or more rigid, and proposes fixes.
• /claude-api hillclimb improves a skill, tool description or system prompt step by step against an eval.
• /claude-api cost-optimize suggests savings from prompt caching, trimmed tokens, effort level and model choice, one change at a time.

To keep a growing skill library tidy, /skill-creator writes and trims skills and /skill-doctor shows what each one costs and how often it is used.

Subagents vs skills in Claude Code

The same trade-off applies if you use subagents day to day in Claude Code. Its documentation says to stay in the main conversation when a task needs back-and-forth, when several phases share a lot of context, for quick targeted changes, and when speed matters. Use a subagent when a task produces verbose output you won’t need again, when you want to restrict its tools or permissions, or when the work is self-contained and can come back as a summary. Skills, by contrast, run inside the main conversation. Custom subagents live as Markdown files in .claude/agents/ for a project or ~/.claude/agents/ for all your projects.

Subagents don’t come free on a subscription: Claude Code’s documentation says their requests count towards the same usage limits as your main conversation. Our guide to making Claude Code limits last covers how to see how much of your usage subagents take. Tool search works the same way for developers in every country where the Claude API is offered, and on Claude Platform on AWS; on Amazon Bedrock it needs the InvokeModel API rather than Converse.

Frequently asked questions

What is the difference between subagents and skills?

A subagent is a separate agent with its own context window, tools and instructions that returns a summary to the main agent. A skill is a set of instructions the main agent loads on demand into its own context, so it keeps everything it has learned in one place.

When should I use subagents?

Anthropic says to use them when a single agent loop shows measurable drops in performance from context bloat, when several tasks need to run in parallel in fresh context windows, or when one agent struggles to pick the right tools or has conflicting instructions. Independent research paths and black-box verification are good fits.

Is a single agent better than a multi-agent system?

Often, but not always. In Anthropic’s comparisons across several enterprise deployments, a single agent with skills frequently beat subagent designs on quality, usually at lower cost and latency. It recommends measuring with an eval and keeping a subagent only if the folded version scores worse.

How many tools can one Claude agent handle?

Anthropic’s documentation says tool choice tends to degrade once more than 30 to 50 tool definitions are loaded. Tool search gets round that by loading tools on demand, and supports up to 10,000 deferred tools per request.

Do subagents use more tokens?

Every subagent call is a nested model loop, which Anthropic says adds latency, and each one hands back a lossy summary. In Claude Code, subagents keep verbose output out of your main conversation, but their requests count towards the same usage limits.

Should a subagent talk to the user directly?

Only when it really needs to. Anthropic recommends the main agent calls subagents as tools and keeps holding the conversation, with a full handoff reserved for a subagent that must talk to the user itself.

What is the single-agent-loop-kit?

A free, Apache 2.0 licensed Claude Code skill from Anthropic on GitHub. It audits a multi-agent system, gives each subagent a verdict (fold, merge, call as a tool or keep) and tests each change against an eval. Anthropic does not maintain it.

What is a Frankenprompt?

Anthropic’s name for a system prompt that every team has added its own sentence to, leaving conflicting rules and no consistent voice. It recommends one small central team owns the system prompt and end-to-end quality.

Last checked: October 24, 2026, against Anthropic’s October 22 article on folding subagents into the main agent loop, the single-agent-loop-kit README, the tool search documentation and Claude Code’s subagents documentation.

Sources: Anthropic, “Building agents: When to fold subagents into your main agent loop”, Anthropic, single-agent-loop-kit on GitHub, Claude Platform docs, “Tool search tool”, Claude Code docs, “Create custom subagents”, Anthropic, “Building multi-agent systems: when and how to use them”.