When to Fold Subagents into Your Main AI Agent Loop: Anthropic’s Practical Guidance

Anthropic’s Latest Guidance: Streamlining Enterprise AI Agent Design

If you’re knee-deep in building AI agents on the Claude Platform, Anthropic’s Applied AI team has a fresh set of recommendations you’ll want to consider. The crux: for many organizations, instead of spreading specialist subagents all over your stack, you’ll probably get more mileage from consolidating them into one main agent loop. Their data, pulled from recent enterprise deployments, points to a simple truth—a unified agent usually gives you better results, trims costs, and speeds up responses compared to managing a crowd of subagents.

What’s New: Rethinking the Multi-Agent Approach

Anthropic’s team has seen firsthand that while subagents are still useful for certain complex or parallel tasks, most enterprise needs call for cutting back on architectural sprawl. To help with this, they’ve released a migration kit that walks your team through deciding if and when to merge subagents into the main loop. The kit lays out a step-by-step approach: spot your existing agent patterns, weigh your options, and experiment in a safe, mock environment before pulling the trigger on production changes.

Historically, subagents—each with their own context, tools, and instructions—have been a go-to for things like verification, parallel workflows, or splitting up permissions. Anthropic’s own research systems on Claude Platform use this pattern. But after practical comparisons across several real-world enterprise setups, a clear trend emerged: a single agent setup with the right skills often outperformed both the “giant one-prompt” model and the subagent-heavy design.

This wasn’t just about quality—the single agent also delivered on cost and latency.

Take one enterprise as an example. Their customer-facing agent depended on a dozen subagents, but this led to a messy brand voice and slow responses—pain points users noticed. After folding those subagents into one main loop, the company achieved a smoother, more consistent experience and much faster replies.

Anthropic calls out a familiar trap here—Conway’s Law. Agent designs tend to mirror the company org chart, with each team spinning up its own subagent. That leads to:

• Context management headaches: Handoffs between agents mean details get lost, making it hard to keep things accurate and connected.
• Subagent sprawl: Teams launch overlapping subagents, and suddenly you’re drowning in components with fuzzy ownership and little standardization.
• ‘Frankenprompt’ syndrome: The system prompt becomes a stitched-together mess, cluttered with conflicting rules as every team piles on requirements.
• Unvetted, overly localized evals: Teams optimize for narrow tasks, but leadership ends up steering the ship using diluted or non-representative metrics.
• Latency: Orchestrating multi-agent systems can double your response time. In one case, switching to a single agent loop cut runtimes in half.

From Anthropic’s recent deployments, a pattern stands out: if you equip a single agent with a clear prompt, a handful of focused data tools (4-5), and strong guardrails, it generally outperforms both one-size-fits-all and multi-agent approaches. That same enterprise with a dozen subagents saw its brand and speed both improve after moving to a single loop.

Why This Matters for Your Business

If your goal is to unify multiple products or workflows using AI, Anthropic’s findings are especially relevant. The typical playbook—each team builds a specialist agent, then you toss an orchestrator on top—might look reasonable, but it usually adds complexity, slows things down, and fragments your quality control.

Anthropic’s “progressive disclosure” method—where the agent loads skills and tools only as needed—keeps context lean and makes better use of models like Claude Opus 4.5 and up. By using this approach, Anthropic reports they slashed Claude Code’s system prompt for new models by over 80%, making the agent more efficient and easier to keep up-to-date. This also means you’re not locked into rigid architectures that make future upgrades a hassle.

Picture a support operation: instead of shuffling a user query through a conveyor belt of subagents (order lookup, shipping, returns), a single well-tooled agent can handle everything in one go. You cut down on handoffs, reduce delays, and give both users and support staff a more consistent experience. Plus, the agent can connect the dots between steps, offering richer insights than siloed subagents ever could.

That said, Anthropic does flag some cases where subagents remain useful—namely, when:

• The main loop bogs down from too much context.
• Tasks genuinely need parallel handling, with fresh, disposable context windows.
• One agent can’t reliably pick the right tool, or prompt instructions start to contradict each other.

For most business workflows, though, you’ll get the best mix of performance, maintainability, and user experience by sticking with one agent loop, progressive disclosure, and disciplined tool and skill management.

Practical Steps: How to Simplify Your Agent Architecture

• Assess your current setup: Start with Anthropic’s migration kit—it’ll help you map your existing agent structure and spot where consolidation makes sense. The guided workflow lets your team compare current subagent patterns, test alternatives, and safeguard production by previewing changes first.
• Build shared evals: Use a centralized evaluation set to measure end-to-end quality, not just subtask wins. Anthropic recommends beginning with 10 golden examples, scoring the agent’s final output with a rubric. Track routing accuracy as you migrate (did the orchestrator pick the right subagent?) and, after consolidation, whether the agent chose the right skill or tool.
• Merge by context: Focus on folding in subagents that interact often or share data. Merge specialists that depend on each other’s output, use the same data, or are usually called together. If traffic regularly flows from one specialist to another, that’s a consolidation opportunity.
• Turn subagents into tools and skills: Convert subagent logic into tools (for actions or data) and skills (for process knowledge). Prompts from subagents become skills, API calls become tools. This lets the main agent keep context and only invoke tools when necessary, minimizing lossy handoffs.
• Limit tool sprawl: Organize tools by user intent, and avoid exceeding 30-50 tools in the system prompt—beyond that, tool selection suffers. Use tool search and deferred loading, and bake preconditions into the tools themselves.
• Centralize quality control: Appoint a small central team to own the system prompt, vet new skills/tools, and maintain the eval rubric. Make sure they review each addition before launch to keep your agent’s quality and consistency intact.
• Monitor and iterate: After each round of consolidation, use your shared eval set to compare performance. Don’t just look at overall scores; dig into which tasks got better or worse. Anthropic found that folding subagents can sometimes break things that previously worked, so ensure your eval covers every critical workflow and rule. Repeat tasks multiple times to catch intermittent problems.
• Leverage migration tools: Anthropic’s migration kit brings API skills like /claude-api build-eval (for eval sets), /claude-api prompt-audit (to spot outdated prompts), and /claude-api hillclimb (for iterative improvements). These take the manual grind out of refining your architecture.

From Multi-Agent to Single Loop: Implementation Considerations

Getting to a single agent loop is more than just gluing code together. Anthropic’s advice:

• Run one model and one context window in a tool loop, with cost and interaction limits in place.
• Let the model send batches of tool calls to run in parallel, then decide on the next move—another batch, a question, or a final answer—based on the results.
• Have the model write and revise its own plan in context, so you don’t need orchestrator code to shuffle plans between agents.
• Move ordering and domain logic into skills, and stick validation or approvals into tools.
• Use code only for the cheap, mechanical stuff (like entity resolution or building payloads).

This design keeps everything relevant in the agent’s context, making it easier to adapt and learn across tasks. It also streamlines upgrades to newer models, since you’re not tangled up in orchestration logic.

How Teams Can Contribute to a Unified Agent

With a single loop, teams shift from owning subagents to curating skills and tools. A tight central team manages the system prompt and overall quality, reviewing every new piece before it’s added. Skills codify your process—steps, rules, decisions—while tools handle actual actions, data, and permissions.

Anthropic provides utilities like /skill-creator (to build and audit skills) and /skill-doctor (to analyze usage and weed out unused entries), helping you avoid skill bloat and keep your library sharp.

Knowledge bases still have a role, especially for reference material that’s needed only sometimes. Use search or lookup tools to fetch facts, policies, or specs on demand, rather than stuffing every prompt with them. Anthropic recommends against hard-coding such references, which just add unnecessary context weight.

My Take: Simplicity Pays—But Discipline is Essential

Anthropic’s recommendations cut through the noise for anyone wrestling with agent sprawl. It’s tempting to reproduce your org chart in your agent architecture, but that rarely leads to good outcomes. In my view, most business needs call for a disciplined, centrally managed agent that flexibly loads only the skills and tools needed, instead of a maze of subagents.

Still, making this transition isn’t a walk in the park. Shifting from a multi-agent approach to a single loop takes solid planning, strong evaluation, and ironclad central oversight. If you fold in subagents too quickly, workflows can break. And for use cases where tasks really are independent—think research or highly specialized domains—subagents still have a valid role.

One unresolved challenge: how fast can organizations adjust their internal cultures to support a central agent team, especially if team ownership and incentives are deeply rooted in silos? Technically, the migration might be the easy part.

The Bottom Line

Anthropic’s guidance is straightforward: for most enterprise AI projects, a single, well-managed agent loop beats a sprawling subagent architecture on every practical measure. The key is discipline—centralize quality, manage your tools and skills tightly, and keep things as simple as your needs allow.