Source: Anthropic, "Building agents: When to fold subagents into your main agent loop" (Diane Sarkis, claude.com resources, 2026-10-22); highlighted by Ethan Mollick on LinkedIn (2026-11-17), who reads it as a call to rethink many company-built agent harnesses. The article draws on Anthropic's Applied AI team's enterprise deployments. Its comparisons are described, not published as a dataset.
The claim
In many enterprise deployments, a single agent with skills beat both a one-giant-prompt design and an orchestrator-plus-subagents design on quality, often at lower cost and latency per task. One customer saw roughly 2x faster runtime moving from a multi-agent harness to a single loop. Many proposed architectures (intent classifier, fixed multi-step pipeline, user-segment buckets, recommendation branches, orchestrator on top) were doing work the model no longer needs done for it. Often one clear system prompt, four or five thin data tools and firm output guardrails cover most of the use case.
Why multi-agent designs go wrong in large organizations
The common path: each team builds its own agent for its capability, then a platform team puts an orchestrator on top, so the architecture mirrors the org chart (Conway's law). The article names five costs:
Context management: deciding what passes between agents, and losing detail in the handoffs.
Subagent sprawl: hundreds of overlapping subagents with no standards and no owner.
The "Frankenprompt": every team adds a sentence to the system prompt, producing conflicting rules and no consistent voice.
Localized evals: each team optimizes evals for its own subtask; nobody owns the whole set, so leadership sees diluted scores.
Latency from the extra hops.
The recommended design
One model and one context window run an open-ended tool loop, with limits in the harness: turn and cost budgets, write gates.
Each turn the model emits a batch of tool calls; the harness runs them in parallel and returns raw results to the same model, which decides the next step: another batch, a question, or an answer.
The loop ends on an answer or a budget; an optional goal or verifier check can run after.
The model writes its plan in context on the first turn and revises it as results arrive. This is the main change: the planner and executor are the same model, so the plan can change mid-task.
Progressive disclosure: the agent sees short descriptions of skills and tools, and loads the full content only when needed (skills for procedure and ordering; tool search for tools). The article notes Claude Code's system prompt for advanced models was cut by over 80%, partly through this.
Where things go: ordering and domain procedure into skills; hard limits (validation, approval gates) and mid-conversation lookups (memory) into tools; cheap, almost-always-relevant loading (entity resolution) and mechanical parts (payload construction, stream parsing) in code inside tools.
Ownership: one small central team owns end-to-end quality and the system prompt, and vets every new tool and eval before it ships.
When subagents still earn their place
Measurable degradation from context bloat in a single loop.
Parallel work that benefits from fresh, discardable context windows.
A single agent that can't pick the right tools, or a system prompt with conflicting instructions.
If you do split, divide by context, not by problem type: give each subagent work that needs little from the rest of the system and returns a compact result (independent research paths, components with clean interfaces, black-box verification). Splitting by problem type creates a "telephone game" where each handoff loses fidelity.
Why now
The article's argument is model capability. Since Opus 4.5, models manage far more in one loop than teams expected; current models always think, narrate progress and check their work, which makes some harness elements redundant. Simpler loops also migrate more easily to the next model. Rigid multi-agent structures were often what stopped a new model from doing more of the work.
Tradeoffs
Shared context vs isolation. One window lets the agent connect earlier results, but it removes the clean security and permission boundaries separate agents give. Write gates and approval tools have to carry that load.
Central ownership vs team autonomy. A single owner of prompt and evals prevents the Frankenprompt but becomes a bottleneck if under-resourced.
Progressive disclosure depends on descriptions. Skills and tools that don't trigger at the right time fail silently.
Vendor perspective. The evidence is the vendor's own deployment experience, and the recommended primitives (skills, tool search) are its platform features. The design principles, though, are framework-neutral.
Failure modes to watch
Context bloat creeping back as skills and tools accumulate, with no measurement to trigger a split.
Losing the verification benefit of a fresh-context reviewer when everything folds into one loop.
Budgets and write gates left too loose because the loop is "just one agent".
Review checklist
Does each subagent exist because of context, parallelism or tool-selection limits you have measured, or because a team owns it?
Is there one owner for the system prompt and the full eval set?
Are procedures in skills and hard limits in tools, rather than in a growing prompt?
Are turn, cost and write budgets enforced in the harness?
Where you split, does each subagent return a compact result and need little shared context?
Is a verifier kept separate from the loop that produced the work?
Would your architecture survive a model upgrade without re-plumbing?
Related
R017: fresh-context subagents as reviewers.
R128: a single agent built mostly from context: templates, skills and stage rules.
R131: harness edits that don't transfer across models.