In my stack, the frontier model tier lists at $10 in and $50 out per million tokens. The tier below it runs $5 and $25; the value tier $3 and $15. Which decisions need the frontier tier is the load-bearing question, because on a working day the honest answer covers a small minority of the tokens.
The split
The architecture is a conductor and its executors, all running on Claude Code. The conductor, the strongest model in the session, does the judgment work: architecture, ambiguity, security-sensitive decisions, and the final verdict on everything the executors produce. Executors, pinned to cheaper tiers, do the bulk work: implementation from a written spec, mechanical transforms, recon sweeps, test writing against defined cases. The dividing heuristic is detection cost. Judgment failures are expensive to notice. Grunt failures show up in a test suite, which is what makes them safe to delegate.
One rule holds even when it looks wasteful: executors always run at maximum reasoning effort. The economy is the per-token price of a smaller model; the thinking budget stays flat. A cheap model thinking hard is a bargain.
The dispatch contract
Delegation fails on missing context before it fails on model quality, so every dispatch carries a contract. It gets a spec with explicit acceptance criteria and a file-ownership map. It gets a shared context file that I write before the first dispatch and update at every gate, so later executors inherit decisions instead of re-deriving them. And it gets an escalation rule: on a design decision, on spec ambiguity, on anything security-shaped, or after two failed attempts at the same step, the executor stops, writes up the blocker with options and a recommendation, and returns early. Escalating crisply is the job. Guessing is the failure mode the contract exists to prevent.
Results come back through blackboards, durable files on disk, because final messages truncate and worktree cleanup can eat an agent's output. The report lives where nothing can lose it. The closing message is a pointer.
The validation gate
No executor output reaches anything real without a gate: read the blackboard, not the summary; diff the owned files; walk the acceptance criteria one by one; confirm test output is pasted, not claimed. On failure there is exactly one re-dispatch, usually with the model escalated a tier. A second failure means I take the work over myself. Never a third attempt — the third attempt is where delegation quietly becomes gambling.
When parallelism hurts
The fleet instinct is to parallelize everything, and it is wrong often enough to need a rule. Breadth-shaped work — many files, many independent surfaces — parallelizes well. Sequential reasoning does not; a chain of decisions split across agents loses the thread that made the decisions coherent. Orchestration also has a hard physical limit: an orchestrator's context fills after ten or fifteen children per step, so large fleets run in waves or they run into a wall. Every spawning loop carries an iteration cap and a budget guard; the fifty-agent audit that taught that rule is told in The policy engine. When in doubt, run one wave, read the results, and then decide whether more coverage buys anything.
The arithmetic
A heavy day of executor output runs into the millions of tokens. At frontier output pricing, two million tokens is $100. Routed through the middle tier it is $50, and the slice that fits the value tier costs $30. In practice, with roughly four-fifths of bulk output on executor tiers and all judgment held by the conductor, bulk spend drops by about half while the gates hold the decision quality. The conductor exists to be wrong less in the places where wrong is expensive.