The Cheap-Subagent Architecture: Why AI Agent Orchestration Wins in 2026

The most important number in AI coding this month is not a benchmark score. It is $0.10 — what Claude Haiku 5.5 charges per million input tokens, one-fortieth of Opus 5.5's input price. That buys a dozen workers on a task that used to justify one expensive model.

But "many cheap agents" is not an architecture. Naive multi-agent teams cost 1.8 to 7 times more per task, and the quality gain is not guaranteed. The teams that win use cheap subagents for isolated, checkable work and keep expensive reasoning for planning and judgment.

What changed in October 2026

Haiku 5.5 makes the worker tier real

Anthropic released Haiku 5.5 on 7 October 2026 at $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens; above that, $0.50 and $2.50. Cache reads are $0.01 and $0.05, and batch processing takes another 50% off (Anthropic model pricing). Against Sonnet 5.5 ($2/$10, 28 September) and Opus 5.5 ($4/$20, 22 September), that is 20 to 40 times cheaper per token.

One caveat: the newer tokenizer counts identical text as roughly 30% more tokens than Haiku 4.5 did. Anthropic's "about 90% cheaper" claim is directionally right for short prompts, not a budget line.

Claude Code adds an effort dial and a token budget

Claude Code v2.1.290 (5 October 2026) gave subagents a computed effort level and a total-token budget; v2.1.292 (7 October) added an effort parameter to the Agent tool, so the orchestrator can spawn the same agent type at different reasoning depths (Claude Code releases). An organization-level maxEffortLevel still caps requests, and the accepted values are not clearly documented — test what your version accepts.

The design point matters more than the flag: a subagent now knows how hard to think and how many tokens it may spend. Those two controls make cheap fan-out governable. v2.1.293 then made Haiku 5.5 the default Haiku model, which is what turns the tier from an option into the default worker.

Codex parallelizes the cheap part

Codex CLI 0.161.0 (7 October 2026) made GPT-6.1 Sol the default model and added /mcp login; 0.163.0 (15 October) enabled parallel execution of read-only tools — skill, memory and history lookups — and made mid-response steering the default; 0.164.0-alpha followed on 16–17 October (Codex releases). Subagent workflows were already on by default: specialized agents run in parallel, each with its own model and tool work, and results are collected into one response. OpenAI's subagent documentation warns this consumes more tokens than a single-agent run.

The scoping is the lesson: reads are parallel, writes are not. That is the safe half of concurrency, and where most search-and-gather work lives.

The scale test: Scion and Antique

Anthropic's 13 October 2026 engineering post on redesigning source control is the best available evidence for what cheap, plentiful agent work does to the rest of the system. Daily merges rose from roughly 2,500 in May to more than 30,000 by September, peaking at 30,401 on 9 September, and CI performs about 25 million code checkouts a day. Anthropic replaced Git with an in-house centralized system called Scion and built a review surface called Antique alongside it.

Two details matter for orchestration. First, the company's own framing is that "the latent demand for merging code is practically infinite" — cheap generation expands work until something else constrains it. Second, adversarial review pushed Claude toward over-engineering hypothetical concerns, and engineers spent much of their time telling the agent no. Fan-out multiplies proposals; it does not multiply judgment. Whatever your architecture, the verifier is the part that decides whether cheap work becomes throughput or backlog.

The economics: why one big model is the wrong default

Per-token price is the wrong metric

Solvency's August 2026 analysis re-derived model comparisons as cost divided by pass rate. The per-token gap understates the per-solved-task gap by a factor of five, widening from 42 to 145 times across thirteen configurations. DeepSeek V4 Flash is 11–19 times cheaper per token than Opus 5 but roughly 100 times cheaper per solved task. Token price says nothing about tokens burned or whether the task closes.

Heterogeneous teams win on cost

The 12 October 2026 study Scaling Inference-Time Compute with Teams of Coding Agents found a heterogeneous 17-agent team within 1.4 points of a strong homogeneous 5-agent team at 70% lower cost. The lesson is allocation, not headcount: which model, how many workers, which subtasks.

Delegate planning, not implementation

The same study found the best reward-cost frontier came from a lead that delegated only planning, then implemented and verified the work itself. Planning is where parallel exploration pays; implementation is where coordination compounds. A shared-task-list study published in the International Journal of Computer Applications in 2026 (Kukkala) found teams improved solve rates by 17% and cut regressions by 25% at up to 2.9 times the tokens on moderately coupled work.

Vals AI's case study of 9 October 2026 adds caution: on full-app builds, the team advantage was statistically significant for only one model at one effort level. For Claude Opus 5.5 it was not significant at either level. Multi-agent is a tool, not a law of nature.

The cheap-subagent reference architecture

Planner expensive, workers cheap, verifier independent

Use the flagship model or a high effort tier for one job: decompose the task into units with explicit acceptance criteria, file scope and a definition of done. Workers get Haiku 5.5 or a mid-tier model, one unit each, with no permission to expand scope. Verification is separate: deterministic checks first (tests, types, lint), then an independent reviewer that did not write the code. Never let the worker grade its own homework.

Make the budget part of the prompt

A token budget only works if the worker knows it. Claude Code's total_tokens_reminder is the pattern: pass the cap into the subagent's instructions, with a turn limit and a stop condition. Ask for a fixed return shape — diff, tests run, open questions — so the orchestrator can compare results without reading an essay. A worker that knows its cap stops exploring; one with an unlimited budget tours the repository.

Isolate writes

Parallel reads are safe. Parallel writes are merge conflicts with better marketing. Give each worker a disjoint file set, serialize edits through the orchestrator, or isolate each branch in a worktree. Codex's read-only constraint is worth copying in your own harness.

Model routing: match effort to the cost of being wrong

Low effort, cheap model

Repository search, call-site inventory, dependency listing, mechanical renames and test scaffolding. These are verifiable and easy to retry, so a wrong answer is cheap to catch.

Medium effort, mid-tier model

Implementation against a written spec, test writing, documentation and small refactors. The spec does the heavy lifting; the model needs competence, not brilliance.

High effort, flagship model

Ambiguous bugs, architecture, security review, data migrations and final judgment on whether a change should exist. Route by the cost of being wrong, not by task size. A one-line auth change deserves more reasoning than a 500-line docs rewrite.

What tiering costs on a twenty-ticket sprint

Here is the arithmetic, at list prices, with every assumption stated so you can replace them. Assume each ticket needs roughly 900,000 input and 50,000 output tokens when handled end to end by one agent.

• Solo flagship: 900K input at $4 and 50K output at $20 is about $4.60 per ticket, or $92 for twenty.
• Cheap solo: the same volume on Haiku 5.5 is about $0.12 per ticket, or $2.30 — but you should expect more retries and a lower first-pass rate.
• Planner, workers, verifier: the flagship planner spends roughly 40K input and 8K output per ticket (about $0.32); Haiku workers do the implementation (about $0.12); a Sonnet 5.5 verifier reads the diff and test output for roughly 120K input and 10K output (about $0.34). That is $0.78 per ticket, or $15.60.

Even if a fifth of the tickets fail verification and need a flagship redo at $4.60, the orchestrated total lands near $34 — under the $92 solo run, with an explicit verification step the solo run did not have. The point is not the exact figure; it is that the plan-and-verify layer costs a fraction of the work it guards. Recompute with your own token telemetry before you quote it internally.

Failure modes that erase the savings

Fan-out without decomposition

Spawning five agents on "improve the codebase" produces duplicate work, conflicting edits and a synthesis step that costs more than the task. An empirical study of 409 fixed bugs across five agentic frameworks (arXiv, October 2026) found orchestration faults and context mismanagement as distinct root causes — not just model errors propagating. Decompose by file ownership and interface boundaries, not by topic.

Verification debt

Cheap generation shifts cost downstream. If review is already the constraint, tripling output triples the backlog; the studies measure tokens and solve rates, not the human review bill. Anthropic's need to build Antique is the large-scale version of the same problem.

The tokenizer and retry tax

Haiku 5.5's tokenizer adds roughly 30% to token counts for identical text. Cheap models can also take more turns, retry more often and miss cache more easily. A model 40 times cheaper per token that takes four times the turns is only 10 times cheaper — before the verification pass.

Coupled work and regulated environments

If two tickets touch the same module, parallel workers will collide; run them serially or not at all. And where a regulation requires named human approval per change — payments, health data, safety-critical firmware — auto-verification and auto-merge of low-risk diffs are not on the table. Keep the planner and the budget controls, drop the automation of the gate, and treat the agent output as a draft with provenance.

How to measure it: cost per solved task

Define "solved" before you compare

Pick a definition you can automate: tests pass, the change is accepted in review, and it is not reverted within seven days. Without the third condition you are measuring activity, not outcomes.

Instrument every delegation

Record task id, parent task, model, effort tier, input/output/cache tokens, turns, wall-clock time, retries and outcome. Aggregate by task class. You want cost per solved task for search, implementation and review separately; a blended average hides one class subsidising another.

Run a 20-task bake-off

Take twenty real tickets. Run three configurations: solo flagship, solo cheap model, and planner plus cheap workers. Compute cost per solved task and quality for each, then disable concurrency on tightly coupled tickets and rerun. Most teams discover the winning configuration is not the one with the most agents.

FAQ

What is a cheap-subagent architecture?

An expensive planner decomposes work, cheap models execute isolated subtasks under explicit token budgets, and an independent verifier checks the result. Savings come from allocation and isolation, not from replacing every model with the cheapest one.

Is Claude Haiku 5.5 good enough for coding?

For search, inventory, test scaffolding and implementation against a clear spec, yes. It is terminal-capable at $0.10 per million input tokens. It is a poor choice for ambiguous architecture or security decisions, where a wrong answer costs far more than the saving.

Why do multi-agent teams cost more than a single agent?

Each subagent performs its own model and tool work, so tokens multiply. Studies report 1.8 to 7 times the cost per task. Careful designs recover most of the quality at a fraction of the premium by delegating planning, using cheaper heterogeneous workers and avoiding concurrency on coupled work.

How many subagents should I run?

As many as you have disjoint, verifiable units of work. A useful ceiling is the number of independent file sets or interfaces; if two workers can touch the same file, they should be one worker or serialized.

What should I measure?

Cost per solved task, not cost per token. Define solved as tests passing, review accepted and no revert within seven days; instrument tokens, turns, retries and wall time per delegation; compare configurations on the same ticket set.

The through-line

October made cheap subagents viable: Haiku 5.5 at $0.10 per million input tokens, an effort dial and token budget in Claude Code, parallel read-only tools in Codex. It did not make naive fan-out profitable. The architecture that works is deliberately boring — expensive planning, cheap isolated execution, independent verification, and a budget on every worker.

For the harness, see the harness is now a product you can rent layer by layer; for the metric, cost per solved task; for October's releases, the full roundup; and pricing starts with the cheap tier.

The test is simple: if a cheaper configuration does not lower cost per solved task, it is not cheaper.

Sources

All links checked on 18 October 2026.

• Claude Haiku 5.5 announcement and model pricing — Anthropic, 7 October 2026.
• Claude Opus 5.5 pricing and Sonnet 5.5 — Anthropic, 22 and 28 September 2026.
• Claude Code releases — v2.1.290 (5 October), v2.1.292–v2.1.293 (7 October 2026).
• Codex CLI releases — 0.161.0 (7 October), 0.163.0 (15 October), 0.164.0-alpha (16–17 October 2026).
• Subagents in Codex — OpenAI documentation, October 2026.
• Redesigning source control at Anthropic — 13 October 2026 (Scion, Antique, 30,401 merges on 9 September).
• Scaling Inference-Time Compute with Teams of Coding Agents — 12 October 2026.
• Shared-task-list agent teams — Kukkala, IJCA 2026.
• Do Agent Teams Pay Off? — Vals AI, 9 October 2026.
• Cost Per Solved Task — Solvency, August 2026.
• Dissecting Bug Triggers and Failure Modes in Modern Agentic Frameworks — 409 fixed bugs across five frameworks, October 2026.