VOLLENDATA
Randall Vollen

Type to search titles, summaries and topics.

Article · October 28, 2026

One agent loop or many: a personal multi-model rig measured against Anthropic's advice to fold subagents

Anthropic now advises collapsing specialist subagents into one agent loop that loads skills on demand. My rig hands bounded work from one Claude Opus parent to cheaper models from four vendors. This piece sets Anthropic's advice beside vendor guidance, published measurements and my own logs, then lists six changes to the rig.

· 11 min read · Randall Vollen

Illustration: on the left, one continuous gold ring with small modules along it; on the right, a central gold node linked to four smaller nodes, one by a dashed line, on a navy background
Generated illustration (Krea 2)

Key takeaways

  • For coding, published measurements back Anthropic: splitting shared-context work across agents lowered scores and raised token use.
  • Anthropic's evidence comes from commerce and support agents, so transfer to coding and research is a hypothesis to test.
  • My rig splits work to spread load across model allowances, keeps one writer per change and leaves acceptance with Opus.
  • The missing piece is an end-to-end evaluation of accepted work, routed by how coupled a task is before routing by price.

Bottom line

Anthropic's advice holds for coding: across five vendors and two independent studies, splitting shared-context, sequential work across agents lowers quality and raises token use. My rig has a second purpose that advice does not address. It spreads work across flat-rate and free model allowances, keeps one writer per change, and leaves acceptance with a frontier model. The missing piece is the one Anthropic puts first: an end-to-end evaluation that shows when a handoff is worth its cost. I will route each task by how tightly it is coupled to other work before routing it by price, and count accepted work instead of dispatched work.

What Anthropic recommends and where its evidence comes from

Diane Sarkis of Anthropic's Applied AI team published the article on 22 October 2026 [1]. It argues that many multi-agent enterprise systems would run better, cheaper and faster as one model, one context window and one open-ended tool loop. Procedures go into skills, hard limits go into tools, and the model sees each as a short description until it needs the full text. Across several deployments, a single agent with skills "frequently outperformed both the one-prompt-for-everything design and the subagent design." One customer's multi-agent harness ran about twice as slow. Tool choice degrades past 30 to 50 tool definitions.

The article lists the costs anyone who delegates real work will recognize: context lost at each handoff (a "telephone game"), added latency from nested loops, sprawling and conflicting prompts, local evaluations that never roll up, and "the agent architecture becoming a copy of their org chart." It keeps subagents for three jobs: parallel independent work that benefits from a fresh, discardable context; measured context bloat; and black-box verification. The migration is incremental. Teams build about ten golden end-to-end evaluations, fold one subagent at a time, run each task more than once, and keep a subagent only when the folded version scores worse. In the article's own example, a regression appeared in only one of two runs.

Scope of the evidence: the examples come from enterprise commerce and support agents, a customer-facing agent with a dozen specialists and a sample support agent with a shipping specialist. The comparison data links to a piece on effective commerce agents. The article publishes no method, sample size or dataset. Brand consistency, customer latency and per-user permissions matter less for long code changes or for a solo developer balancing model costs. Transfer to coding is a hypothesis for my own tests to settle.

What I run and how I tuned it

The rig is a personal engineering, research and media workstation. A Claude Opus parent session owns architecture, sensitive or live operations, and final acceptance. A written routing policy sends bounded work out in a fixed order:

  1. Flat rate: MiniMax M3 on a subscription builds and explores scoped private code by default.
  2. Free or included: a pinned free OpenRouter model, Antigravity, Kiro, NVIDIA's hosted inference service (NIM) and Grok take public or sanitized work where a lane's data terms require it.
  3. Escalation: Codex and Claude, including OpenAI's GPT-6 Astra driving the Claude Code harness through a local gateway.
  4. Paid, last: paid OpenRouter runs only after I announce the model, price and budget. Nothing falls back to a paid model silently.

Each lane has its own data permission. Only some models may see private code, and secrets stay on the machine. A model-pinning hook sets native Claude subagents to Haiku unless the parent states a reason to use a larger model. Context loads on demand at every layer. A short entry file points to the routing policy, the policy points to an operations note read "only for the relevant task," 34 skills and a deferred tool registry appear as short descriptions, and a memory index of one-line pointers opens any of 277 memory files only when relevant.

Most of the tuning came from failures, and each lesson became a rule, a test gate or a skill reference:

  • Delegation was synchronous. My own 57-day audit of 1,339 agents (July to September 2026) found one agent running for 78% of active time. While M3 workers ran, the parent sat idle for 60% of that time and resumed a median 6 seconds after each worker finished. Interactive sessions ran at an 8% duty cycle against 96% for headless workers. Detached launchers now let the parent keep working while workers run.
  • Workers graded their own tests. Delegated tests passed without testing anything, read-only workers still changed files, and one worker patched the test environment. The parent now writes and freezes acceptance tests outside the worker's write permissions. A rerun on the same model does not count as independent acceptance.
  • Fan-out inflated findings. A 19-session M3 discovery sweep roughly doubled some counts and made claims the code refuted. A second wave of three adversarial checkers cut the findings down to a list that survived review.
  • Delegated prose invented numbers. Before anything publishes, I check every key figure against its source. That check caught a research worker naming the wrong lead author on a paper cited here.

Over three months the logs record 213 M3 outcomes, 114 Codex outcomes and 36 written rules for delegation and testing.

What other vendors and builders recommend

Five vendors give the same default advice, and two of them publish measurements behind it.

WhoPositionEvidence
OpenAIStart with one agent whenever possible, and add specialists only for capability isolation, policy isolation, prompt clarity or trace legibility [4].Opinion
GoogleIts Agent Development Kit guide says to "start with a sequential chain, debug it, and then add complexity" [5].Opinion
MicrosoftAgent Framework docs say to use a plain function whenever one can do the task, and a workflow only when multiple agents or functions must coordinate [6].Opinion
LangChainIts docs reserve multiple agents for tool overload and context isolation, and say a single agent with the right tools and prompt "can often achieve similar results." Its benchmark found a single agent "falls off sharply" with two or more unrelated domains loaded [7].Measured: τ-bench retail, gpt-4o, 100 tasks
Cognition2025: "Don't build multi-agents." 2026: "writes stay single-threaded" while extra agents review, search or escalate hard steps to a stronger model. Its review agent "catches an average of 2 bugs per PR" (pull request) [8] [9].Production experience
Anthropic, 2025A multi-agent research system beat single-agent Opus 4 by 90.2% on an internal evaluation, at about 15 times the tokens of a chat. The same post says coding offers fewer parallel tasks [2].Measured: internal
Kilo CodeShipped an orchestrator mode, then announced: "Orchestrator mode is deprecated and will be removed in a future release" [10].Product decision
Roo CodeIts orchestrator gives each subtask an isolated history and blocks the parent from editing files to avoid "context poisoning" [11].Product design
Individual developersAn expensive model plans while a cheap model edits: in aider's 2024 benchmark, o1-preview planning with DeepSeek editing scored 85.0% against 79.7% for o1-preview alone [12]. Others route Claude Code subagents to cheaper models through proxies, review a written plan before execution [13], or report cheap loops spending credit quickly on Hacker News.Anecdotal

Anthropic's 2025 research result and its 2026 advice cover different work. Breadth-first research splits into independent pieces, while code repair and customer conversations mostly depend on shared context.

What published measurements show

MeasureResult
SWE-bench Verified, a software engineering benchmarkEvery multi-agent design scored below the single agent's 0.522 mean, by 2.1% to 14.9%
Token overheadMulti-agent designs used 1.6 to 6.2 times a single agent's tokens at matched performance; successes per 1,000 tokens fell from 67.7 to 13.6 at worst
Baseline thresholdOnce a single agent scores above 45%, adding agents lowers results; frontier coding agents score well above that line
Google Research and MIT tested 260 configurations on 6 benchmarks [3].

The same study measured gains as well: +80.8% on decomposable financial reasoning against −70.0% on sequential planning [3]. Independent agents multiplied errors 17.2 times, while a central coordinator that validated outputs held the multiplier to 4.4. Those results favor one writer with a checkpoint.

Four results mark where that conclusion stops:

  • Discovered hierarchies help weaker models. Xu and colleagues' BOAD system, a search method for agent hierarchies, beat a single SWE-agent with a 36B model: 53.2% against 49.8% on SWE-bench Verified and 20.0% against 12.3% on SWE-bench Live. A hand-built multi-agent version scored 47.4% [14]. Decomposition helped below the 45% threshold.
  • Multi-agent systems fail in recognizable ways. Cemri and colleagues' failure taxonomy (MAST) measured failure rates from 41% to 86.7% across seven open-source frameworks, concentrated in coordination and verification [15].
  • Cross-vendor review works in one direction. On 116 LiveCodeBench tasks, Claude reviewing Codex raised Codex from 71.6% to 89.7%, while Codex reviewing Claude lowered Claude from 91.4% to 82.8%. Reviewers could not run tests [16]. Review works when the stronger model checks the weaker model's output.
  • Judges and leaderboards carry more noise than headline scores show. Across 21 model judges, chance-corrected agreement ran 33 to 41 points below raw agreement, and rankings moved by as many as 14 places between benchmarks [17]. On SWE-bench Verified, the 29 adjacent pairs in the top 30 are statistically indistinguishable, while different harnesses on one model spread 29.8 points [18]. Harness design changed results more than model choice, and the harness is the cheapest part to test.

Side by side

DimensionAnthropic (commerce evidence)Other vendors and studiesMy rig
Default shapeOne loop, one contextOne agent first, more for a named reasonOpus parent with cost-routed workers and one writer per change
Reason to splitParallel work, independence, verificationThe same three, plus tool overloadSpreading load across model allowances, plus parallel discovery and review
ContextSkills and tools load on demandMoving toward skillsSame pattern: layered policy, skills, deferred tools, memory pointers
WritesGated in the harnessOne writer at a time (Cognition)Same pattern: frozen tests, separate worktrees, one integration at a time
VerificationBlack-box subagentGenerator plus a verifier with clean contextParent acceptance plus adversarial check waves, with review direction still uncontrolled
EvaluationAbout ten golden end-to-end tasks, each run several timesRarely publishedGap: cost and quota tracking exists, with no score comparing delegation to a single loop
Rule growthWarns against one oversized prompt full of conflicting rulesNo published position36 delegation and testing rules on top of policy and operations notes

A second opinion from another model family

I gave the rig's policy, operations notes, acceptance rules, hook design and rule list to OpenAI's GPT-6 Astra, running headless in the Claude Code harness, and asked it to challenge my first comparison. It corrected me in three places:

  • Warning counts measure lessons recorded. 74 flagged lessons across 213 M3 log entries show no causal link to handoffs, since single loops also write empty tests. Handoff cost stays a plausible explanation until an evaluation measures it.
  • The policy already asks for suitable lanes. It lacks an operational test for coupling, and that test is the change to make.
  • The memory index points to bodies loaded on demand. I had described it as loading everything. Measured, it holds 61 lines, 245 links and about 18 kilobytes in every session, while the 277 memory files load only when needed. Trimming it is a cost saving with no design change.

Its ranked changes overlapped heavily with mine, and I have adopted them as the plan below.

Six changes to the rig

  1. Check coupling before price. The parent classifies each task before dispatch. Changing interfaces, debugging shared state and architecture stay in the parent loop. Stable contracts, read-only exploration, research fan-out and independent checks go to the cheapest suitable lane. Anthropic, Cognition and the Google Research and MIT study draw the same boundary.
  2. Count accepted work. Every delegated task records first-pass acceptance, correction rounds, parent rework time and failure type, and the dashboard shows them beside quota. A free task that costs an hour of parent review then shows its real cost.
  3. Define a paired comparison on ten golden tasks. Two tasks each would cover isolated fixes, coupled interface changes, cross-file debugging, evidence synthesis and pipeline configuration. Each would run three times under a single Opus loop and three times under current routing, for 60 runs on a budget approved in advance. Scoring would be blind to the arm, and every task that passes in one arm and fails in the other would get a manual review.
  4. Control review direction. The stronger model reviews the weaker one. A cheaper model may raise issues on frontier output and has no veto.
  5. Turn repeated lessons into gates and skills. The 36 rules move into a few skill references and automatic checks such as minimum test counts, exit-code propagation and integrity hashes on test files. Each then loads only when relevant.
  6. Trim the always-loaded index. A short core index plus one index per area replaces the single file, with recall tested on known-rule scenarios before and after.

Staying as is: parent-owned acceptance, per-lane data permissions, explicit approval for paid models, frozen tests and isolated writers. Cost-based routing stays too, now with an outcome measure beside it.

Open questions

  • No public controlled evaluation shows whether folding helps frontier coding agents. A ten-task comparison like the one above would add one data point.
  • The cross-review result comes from reviewers barred from running tests. A test-running reviewer could change the direction.
  • Vendors publish token multipliers. Dollar and time costs of coordination per task type remain unmeasured.

Method: three research workers on MiniMax M3 surveyed vendor guidance, practitioner rigs and measured studies, and GPT-6 Astra reviewed the rig. My Claude Opus session rechecked every key figure at its original source and corrected one attribution error. Rig figures come from my own logs.

Sources

  1. Building agents: when to fold subagents into your main agent loopDiane Sarkis, Anthropic. (2026). Retrieved 2026-10-28.
  2. How we built our multi-agent research systemAnthropic. (2025). Retrieved 2026-10-28.
  3. Towards a Science of Scaling Agent Systems. arXiv 2512.08296Yubin Kim et al.. (2025, Preprint). Retrieved 2026-10-28.
  4. Agents SDK orchestration guideOpenAI. Retrieved 2026-10-28.
  5. Developer's guide to multi-agent patterns in ADKGoogle. (2025). Retrieved 2026-10-28.
  6. Microsoft Agent Framework overviewMicrosoft. (2026). Retrieved 2026-10-28.
  7. Benchmarking multi-agent architecturesLangChain. (2025). Retrieved 2026-10-28.
  8. Don't build multi-agentsWalden Yan, Cognition. (2025). Retrieved 2026-10-28.
  9. Multi-Agents: What's Actually WorkingWalden Yan, Cognition. (2026). Retrieved 2026-10-28.
  10. Orchestrator mode (deprecation notice)Kilo Code. Retrieved 2026-10-28.
  11. Boomerang tasksRoo Code. (2026). Retrieved 2026-10-28.
  12. Separating code reasoning and editingaider. (2024). Retrieved 2026-10-28.
  13. How I use Claude CodeBoris Tane. (2026). Retrieved 2026-10-28.
  14. BOAD: Discovering Hierarchical Software Engineering Agents via Bandit Optimization. arXiv 2512.23631Iris Xu et al.. (2025, Preprint). Retrieved 2026-10-28.
  15. Why Do Multi-Agent LLM Systems Fail? arXiv 2503.13657Mert Cemri et al.. (2025, Preprint). Retrieved 2026-10-28.
  16. Cross-Model LLM Code Review: Should you use Claude to review Codex or vice versa? arXiv 2607.21656Zuodong Xiang; Yike Zhang; YueMing Zhang; Hailu Xu. (2026, Preprint). Retrieved 2026-10-28.
  17. Reliability without Validity: A Systematic, Large-Scale Evaluation of LLM-as-a-Judge Models. arXiv 2606.19544Justin D. Norman; Michael U. Rivera; D. Alex Hughes. (2026, Preprint). Retrieved 2026-10-28.
  18. Coding Agents Have Converged. arXiv 2609.17394Fengshuo Liu et al.. (2026, Preprint). Retrieved 2026-10-28.