Why does a single agent loop often run faster than a multi-agent orchestrator?

Orchestrating multiple subagents introduces overhead from separate model calls, serialization, and lossy context handoffs. A single loop keeps state in one context window, executing parallel tool calls directly, which cut runtime by roughly 2x in enterprise evaluations.

What is progressive disclosure in an agent architecture?

Progressive disclosure exposes lightweight descriptions of tools and skills to the model, loading full schemas or instructions only when needed. This prevents context bloat while avoiding the need to spin up separate subagents for different tasks.

When should an enterprise still keep dedicated subagents?

Subagents remain valuable when a single context window experiences measurable degradation from bloat, when isolated tasks must run in parallel with fresh, disposable contexts (such as black-box verification), or when tools conflict directly.

How do 'skills' differ from subagents?

A subagent runs in its own context window with its own coordinator, tools, and state. A skill is a domain procedure or instruction set loaded on demand into the main agent's existing context loop.

When to Fold Subagents into a Single Main Agent Loop

The Multi-Agent Sprawl Trap

Many enterprise engineering and operations teams follow a predictable path when building AI systems. To support multiple business units or product lines, they let individual departments create specialist subagents: an intent classifier, a routing agent, a customer support agent, and a recommendation agent. A platform team then places an orchestrator on top to tie them together.

This structure often mirrors Conway’s Law: the software architecture ends up copying the enterprise org chart rather than serving the underlying task.

Anthropic's Applied AI team highlighted this pattern in their guidance on agent architecture. While multi-agent setups appear modular, enterprise production deployments frequently encounter severe architectural bottlenecks:

The Telephone Game: Passing summaries back and forth between an orchestrator and subagents degrades fidelity. Crucial nuance gets lost during handoffs.
The Frankenprompt: When every team appends instructions to maintain cross-agent guardrails, system prompts grow bloated, contradictory, and impossible to align with a consistent brand voice.
Eval Drift: Decentralized teams build localized evaluations for their specific subagents. When no single owner evaluates the end-to-end outcome, leadership relies on fragmented metrics that mask systemic degradation.
Compound Latency: Each subagent handoff adds an extra inference step and context serialization cycle.

Anthropic found that across several enterprise deployments, folding routers, planners, and domain subagents back into a single agent loop equipped with "skills" consistently outperformed both rigid multi-agent orchestrators and "one-prompt-for-everything" mega-prompts on quality, cost, and execution speed. In one customer evaluation, replacing a multi-agent harness with a single agent loop delivered a roughly 2x faster runtime.

The Convergence Checklist: 3 Signals to Fold, 2 Boundaries to Keep

Before adding another subagent to an orchestration layer, teams should evaluate their architecture against a clear consolidation checklist.

Architecture Dimension	Signal to Fold into Main Loop	Boundary to Retain Subagents
Context & State	Subagents constantly hand summaries back and forth, losing detail in the process.	A single context window suffers measurable performance degradation from extreme bloat.
Execution Flow	Subagents run sequentially merely to triage, route, or execute standard company procedures.	Tasks run strictly in parallel with independent context windows that can be discarded upon completion.
Tool & Prompt Isolation	Specialist agents exist primarily because different teams wanted their own system prompt.	Tools require contradictory permissions or irreconcilable prompt instructions.

3 Clear Signals to Fold Subagents

1. Context Handoffs Are Degrading Output Quality

If an agent needs the full history of earlier steps to make nuanced decisions, dividing tasks across subagents creates blind spots. An agent that observes the raw output of each prior step makes better connections than a coordinator trying to piece together lossy summaries handed back by specialists.

2. The Orchestration Harness Does Work the Model Can Do Natively

Early agent frameworks relied on deterministic code to parse user intent, update task graphs, and route between distinct subagents. Frontier models—such as Anthropic's Opus 4.5, Opus 5.5, and Fable 5.1—feature persistent internal thinking, narrative self-tracking, and dynamic correction. When the harness spends compute managing rigid pipelines that modern models handle natively, the harness adds latency without adding value.

3. Brand Voice and Policy Alignment Are Fragmenting

When customer-facing interactions bounce across twelve specialized subagents, maintaining a unified tone is nearly impossible. Consolidating domain procedures into a single loop allows a single central prompt to enforce company voice and guardrails consistently.

2 Boundaries Where Subagents Remain Essential

1. Severe Context Window Exhaustion

If an enterprise workflow requires reading hundreds of thousands of tokens of dense documentation or tabular data per branch, loading that data into the main context will degrade reasoning. Subagents should handle these heavy, isolated workloads and return compact results.

2. Independent Parallel Execution and Verification

Subagents excel at clean, black-box tasks. Examples include running multiple independent research tracks simultaneously or executing generator-verifier loops where an isolated verifier checks an output without being biased by the generation reasoning chain.

The Architecture of a Modern Single-Loop Agent

Replacing an orchestrator-subagent system does not mean reverting to a single, monolithic prompt that contains every instruction the company has ever written. Instead, the single-loop design relies on progressive disclosure and clear division of responsibilities.

+-----------------------------------------------------------+
|                     MAIN AGENT LOOP                       |
|                                                           |
|  1. Central Model & Single Context Window                 |
|  2. Turn & Cost Budgets (Harness Managed)                 |
|  3. Dynamic In-Context Plan (Revised Mid-Turn)            |
+-----------------------------+-----------------------------+
                              |
         +--------------------+--------------------+
         |                                         |
         v                                         v
+------------------+                     +------------------+
|      SKILLS      |                     |      TOOLS       |
| Domain SOPs &    |                     | Thin APIs &      |
| ordering rules   |                     | Hard validation  |
| loaded on demand |                     | approval gates   |
+------------------+                     +------------------+

1. In-Context Planning Instead of Code Routers

In a folded architecture, the model writes its working plan into its own context window on the first turn. As parallel tool executions return raw data, the model updates that plan dynamically. The model that executes the plan is the model that writes it, eliminating the friction of an external orchestrator trying to adjust a static execution graph.

2. Progressive Disclosure via Skills

Rather than loading hundreds of domain-specific instructions into the initial system prompt, the system exposes lightweight descriptions of skills and tools. The model requests the full instructions or tool schemas only when a task demands them. Using progressive disclosure for skills and tools, Anthropic reduced the system prompt for Claude Code by over 80% on advanced models, drastically lowering context overhead while preserving broad operational scope.

3. Clear Boundaries Between Skills, Tools, and Code

Skills: Store domain logic, procedural guidelines, and ordering preferences. They load into the context window as text instructions only when triggered.
Tools: Execute side effects, query databases, and enforce hard validation or human-in-the-loop approval gates.
Harness Code: Enforces turn budgets, cost limits, and stream parsing. It handles cheap, mechanical tasks like entity resolution before invoking the model.

How to Structure the Migration

Moving from an entrenched multi-agent system to a streamlined single loop requires disciplined organizational ownership. At Starbox AI, we see marketing and growth teams struggle with similar architectural bloat when deploying automated content, campaign management, and customer intelligence pipelines across regional teams.

To migrate without disrupting live services, enterprise teams should adopt a staged consolidation plan:

Form a Single Prompt and Eval Team: Dissolve fragmented subagent prompt ownership. A single, focused platform team must own end-to-end quality, system-level evals, and prompt maintenance.
Convert Domain Subagents into Skills: Extract the specialized instructions from individual subagents and format them as modular skills that the main loop can call via progressive disclosure.
Collapse Intent Routers: Allow the central model to inspect incoming requests and select tools or skills directly, deprecating dedicated classification and routing subagents.
Enforce Turn and Cost Gates in Harness Code: Ensure safety and budget discipline by letting code manage execution budgets, rather than relying on complex agent-to-agent negotiations.

Consolidating your architecture around a single loop with modular skills removes unnecessary infrastructure, preserves crucial context, and cuts system latency in half. As models become more capable, the competitive advantage belongs to teams that simplify their harnesses and allow the model to manage its own reasoning.

This article was written and illustrated by a Starbox AI writing agent and published after automated review. For reference only.

The English edition is rewritten from the original Chinese article on the same topic.