Blog · AI Agent News · Claude & Anthropic VIEN

Anthropic: One AI Agent Loop Beats Subagents, Cuts Prompts 80%

Anthropic says folding subagents into a single agent loop runs 2x faster and trims Claude Code prompts over 80%. Here are the numbers and migration kit.

Anthropic: One AI Agent Loop Beats Subagents, Cuts Prompts 80%
Images: Jemimus / Wikimedia Commons (CC BY 2.0); Tirza van Dijk tirzavandijk / Wikimedia Commons (CC0); Derrick Coetzee from Berkeley, CA, USA / Wikimedia Commons (CC0)
In this article
  1. Single loop vs. subagents: What the benchmarks show
  2. How Anthropic cut Claude Code's prompt by over 80%
  3. How to migrate safely with anthropics/single-agent-loop-kit
  4. Three exceptions where subagents still earn their keep
  5. My take

If you have been splitting every AI workflow into five or six chained subagents, Anthropic just pushed back against the "more bots equals smarter systems" trend. In an engineering guide published on October 22, 2026 and highlighted by The Decoder in November 2026, Anthropic's Applied AI team advised developers to evaluate folding routers, planners, and specialist subagents back into a single main agent loop.

Single agent loop vs. multi-agent subagents comparison
Anthropic reported a single agent loop running roughly 2x faster in enterprise testing, while Vals AI measured agent teams costing 1.8x to 5.1x moreImage: Ahunt, software pictured by System76 / Wikimedia Commons (CC0); OboeBlanket / Wikimedia Commons (CC0)

Single loop vs. subagents: What the benchmarks show

Here is how the two architectures stack up across Anthropic's October 2026 enterprise findings and Vals AI's Vibe Code Bench study reported by The Decoder.

DimensionSingle-agent loopMulti-agent subagents
Runtime speedRoughly 2x faster in an Anthropic customer evaluationSlower due to nested model loops and handoff overhead
Token costLeaner context; Claude Code's system prompt shrank over 80%1.8x to 5.1x more expensive per Vals AI testing on GPT-6 Sol and Opus 5.5
Scaling behaviorHolds steady when kept to 4–5 thin core data toolsAnthropic tests with Opus 5.5 and Fable 5.1 plateaued past 10 agents (Fable 5.1 dipped from 30 to 100 agents on KB tasks)
Main failure modeTool-selection accuracy drops past 30–50 tool definitions in the prompt"Conway's Law" org-chart sprawl and conflicting "Frankenprompt" rules
Best fitMost integrated workflows, coding tasks, and customer assistantsBloated read-heavy contexts, parallel independent jobs, or strict permission splits

Two organizational habits cause most multi-agent bloat, and Anthropic calls them out by name. The first is Conway's Law for agents: each product team ships its own subagent, turning the architecture into a mirror of the company org chart with dozens of overlapping bots. The second is the Frankenprompt, where every team appends its own rules to a shared system prompt until instructions directly contradict one another.

Passing tasks down a chain of specialists also creates a "telephone game" effect. Every handoff relies on a lossy summary that drops context from earlier steps while multiplying API latency—what OpenAI Codex developer Eric Provencher previously called the "coordination tax" of agent swarms.

How Anthropic cut Claude Code's prompt by over 80%

Consolidating into one loop does not mean cramming every manual and API endpoint into a massive system prompt. Instead, Anthropic relies on progressive disclosure through Skills and Tool Search.

Rather than preloading pages of instructions at turn zero, the primary agent runs with a clean system prompt, roughly 4–5 thin data tools grouped by user intent, and short descriptions of available skills. When a task calls for a specific procedure, the agent pulls the full skill instructions or queries the relevant tool definition on demand. That shift allowed Anthropic to trim Claude Code's system prompt by over 80% on newer models without losing capability. Developers looking to trim session overhead even further can pair this pattern with context-capping techniques we compared in Code Mode vs. Tokendoctor on mvcthinh.com.

There is a hard ceiling to watch, though. Anthropic warns that once you exceed 30 to 50 tool definitions in the system prompt, the model's tool selection starts to degrade noticeably. Keeping core tools compact and offloading reference specs into searchable knowledge bases prevents the single loop from drowning in noise.

Also readMeta Muse Signal & Bank Balance Report: Fact vs. Fiction

How to migrate safely with anthropics/single-agent-loop-kit

To keep teams from guessing, Anthropic published the Apache-2.0 licensed anthropics/single-agent-loop-kit on GitHub. It ships with examples/support-desk (one router and six subagents) plus an offline smoke test (KIT_MODEL=fake python3 evals/run_eval.py --variant smoke) covering 19 tasks at zero API cost.

Four measured steps to fold subagents using single-agent-loop-kit
Anthropic's four-step workflow scores a baseline before folding each subagent into skills and toolsImage: Slashme / Wikimedia Commons (CC0); luis gomes / Wikimedia Commons (CC0)

Whether your stack runs on the Claude Agent SDK or a custom Python orchestrator, the kit walks through four measured stages:

flowchart TD
  A[00-audit: Map subagents]:::data --> B[01-baseline: 10 golden tasks]
  B --> C[02-merge: Join coupled bots]
  C --> D[03-fold: 1 bot to Skill+Tool]:::key
  D --> E{Re-run eval score}:::human
  E -->|Score holds/rises| F[Drop subagent, keep Skill]
  E -->|Score drops| G[Keep subagent as Tool]
  classDef key fill:#1d1a10,stroke:#ffd23f,color:#ffd23f,stroke-width:1.6px
  classDef human fill:#181817,stroke:#e8e6df,color:#e8e6df,stroke-dasharray:5 3
  classDef data fill:#1c1c1b,stroke:#8d8b85,color:#cfcdc6
  classDef muted fill:#181817,stroke:#3d3d3a,color:#8d8b85
Diagram: Anthropic's four-step migration to a single agent loop
  1. Audit your current routing (00-audit): Copy skill from the repo into .claude/skills/single-agent-loop and let Claude Code inspect your orchestration code. It pauses to label each subagent as fold, merge, call as a tool, or keep for you to review.
  2. Build a 10-task baseline (01-baseline): If you lack an end-to-end eval suite, the workflow drafts roughly 10 golden examples from real user requests and asks you to confirm what success looks like before any paid runs.
  3. Merge tightly coupled pairs (02-merge): Subagents that routinely run back-to-back on the same records should be combined first to eliminate unnecessary handoffs.
  4. Fold one subagent at a time (03-fold): Convert one specialist's prompt into a Skill and its API actions into lean tools, keeping core definitions around 4–5 tools, then re-score the baseline. Anthropic warns against merging blindly: in its own support-desk test, folding one specialist cut latency but caused the main agent to answer shipping questions directly without checking the shipping specialist—a regression that only surfaced in one out of two runs.

Three exceptions where subagents still earn their keep

Anthropic is clear that a single loop is not a universal rule. Keep a dedicated subagent (often invoked as a tool by the main loop) when you hit one of these three boundaries:

  • Measurable degradation from context bloat: Tasks that read massive logs, codebases, or raw research dumps far exceeding what the main agent needs afterward.
  • Parallel work in isolated contexts: Running independent research threads or editing code while executing tests simultaneously in disposable context windows.
  • Tool-selection limits or strict isolation: Workflows that genuinely cannot stay under the 30–50 tool ceiling, carry irreconcilable instructions, or require independent black-box verification and permission boundaries.

My take

Most multi-agent setups running today are leftovers from older model habits—and a developer urge to draw impressive box-and-arrow diagrams. When models struggled to plan past two steps, splitting work across half a dozen specialized bots made sense. With current frontier models, keeping those rigid layers intact often blocks the model from doing the orchestration better on its own.

In real-world builds—especially for solo developers and small teams paying API bills out of pocket—a clean single loop with progressive skills is the surest way to protect quality and stop burning tokens. Before wiring a fourth or fifth bot into your workflow tonight, run 10 real requests as a baseline, fold one layer back in, and see what happens to both your latency and your monthly bill.

Sources

  1. Building agents: When to fold subagents into your main agent loop Anthropic
  2. anthropics/single-agent-loop-kit GitHub
  3. Anthropic says one AI agent beats many subagents now that models can handle complexity alone The Decoder
  4. AI agent teams waste massive tokens for barely measurable quality gains, research finds The Decoder (Vals AI)

Claude & AnthropicMCP & toolsAutomation

Was this useful?

More on this topic