Cheap-Executor Delegation — Four Shapes of the Same Cost Lever

Source: wiki synthesis: The Advisor Strategy, Coordinator-Pattern Cost, Checker, Codex Inside Claude Code · Cost & Intelligence Levers

By mid-2026 the wiki documents four separately-sourced ways to run a task where an expensive frontier model does a little high-leverage thinking and a cheap model does the bulk of the work. They look different — one has the cheap model in charge, three have the frontier in charge; one hands execution to a rival vendor; one bolts on an independent verifier — but they are the same economic lever wearing four topologies. The unifying rule (the coordinator cookbook’s phrase): big models plan, small models execute — or, more precisely, spend the expensive model’s tokens on judgment and the cheap model’s tokens on volume. This article maps the four shapes side by side so you can pick one deliberately instead of defaulting to “one big model does everything” (the routing failure behind most “my AI bill exploded” stories).

Key Takeaways

• One lever, four topologies. Advisor, coordinator, boss/worker/checker, and cross-vendor plugin-executor are all instances of keep the frontier a minority of tokens. They differ in who drives, where the executor lives, and whether verification is independent — not in the underlying economics.
• Two opposite control-flow directions, same outcome. The advisor shape inverts the usual flow — the cheap model drives and escalates up to the frontier only when stuck (~once per task). The other three delegate down — the frontier drives and hands execution to cheaper hands. Both make frontier tokens the minority: advisor because the frontier is called rarely; delegation because execution volume dwarfs planning.
• The numbers rhyme across all four. ~63% of full-frontier price at ~92% of its score (advisor); 2.5× cheaper / 3× faster (coordinator, rigor-matched); ~$8vs$100, a ~10× gap (boss/worker/checker); a claimed ~60% token cut (plugin-executor, unverified). Different tasks, same order-of-magnitude win.
• Only one shape ships independent verification. The checker topology pairs every worker task with a checker that re-executes it and ignores the worker’s self-report — the operator-side answer to the fact that cheap executors, like any capable model, will game a checkable reward. The other three lean on self-check or a human’s final review.
• Cross-vendor is a real fourth option. Codex-inside-Claude-Code shows the executor need not be a smaller Anthropic model — Fable 5 can orchestrate and delegate the heavy coding to OpenAI Codex, shifting token load onto a different subscription entirely.
• The prerequisite is a router. Every shape assumes something decides which tier gets which task. Without that, the most expensive model gets assigned to everything by default — the single biggest cost blow-up, and an org-design problem, not an AI one.

The four shapes, side by side

Shape	Who drives	Frontier’s role	Executor	Independent verification?	Documented result	Source
Advisor (escalate-up)	the cheap model	consultant, called ~once/task to steer; returns a plan/correction/stop only	same-vendor cheap (Sonnet / Haiku)	no — executor self-checks	Sonnet 5 + Fable 5 advisor: ~92% of Fable’s SWE-bench Pro score at ~63% price; Haiku + Opus: 41.2% vs 19.7% on BrowseComp, 85% cheaper	advisor-strategy
Coordinator / orchestrator (delegate-down)	the frontier	plans, decomposes, synthesizes; holds no reading tools itself	same-vendor cheap parallel workers (Sonnet, scoped to search+fetch)	partial — two-source rule inside each worker	Fable coordinator + Sonnet workers: 2.5× cheaper, 3× faster (rigor-matched, one 20-fact task)	anthropic-cookbook-coordinator-cost
Boss / worker / checker (delegate-down + verify)	the frontier	foreman: writes specs, rules disputes, never codes	mixed cheap model families	yes — a checker re-executes every task, ignoring the worker’s report	Fable boss + cheap workers: ~$8vs$85–105 all-Fable (~10×), 34 tasks / 12 reworked / 0 human fixes	multi-agent-boss-worker-checker
Cross-vendor plugin-executor (delegate-down, other vendor)	the frontier	orchestrator + final reviewer	third-party (OpenAI Codex / GPT-5.5 via plugin)	no — human/frontier reviews the diff	claimed ~60% Fable-token savings ^[inferred — single-author, unverified]	codex-inside-claude-code

The two axes that actually distinguish them

Everything else is detail; two questions place any real system on this map:

1. Which way does control flow? Escalate-up (advisor) keeps the cheap model as the default and only reaches for the frontier at hard moments — best when most steps are easy and a few are genuinely hard, and when you want a single API call with no orchestration code. Delegate-down (the other three) puts the frontier’s judgment first and mass-produces with cheap hands — best when the work decomposes into many similar sub-tasks.
2. Where does the executor live, and is it checked? Same-vendor workers are the simplest; a cross-vendor executor lets you spend a second subscription’s tokens (useful when your frontier budget is the bottleneck) at the cost of two auth surfaces and no shared context. And independent verification is an orthogonal add-on: the boss/worker/checker shape is really the coordinator shape plus a re-executing checker — bolt that verifier onto any delegate-down system when the work has a cheap, objective ground truth (a compiled build, a fetched URL, a WCAG check).

The economics that unify them

In every shape the expensive model touches only the judgment minority of tokens and the cheap model absorbs the volume majority:

• Advisor: the frontier’s plans are short (~400–700 tokens) and it’s invoked ~once per task, so advisor tokens are a rounding error against the executor’s full output.
• Coordinator / boss: the frontier plans and synthesizes; the token-hungry reading and writing is done in parallel by cheap workers at the cheap rate. Fable output is $50/M; the whole point is to keep as few tokens as possible at that rate.
• Plugin-executor: the heavy implementation is billed against a different subscription entirely, so it never hits the Fable budget.

The measured wins (2.5×, ~10×, ~37% off, ~60%) are all this same arithmetic. The catch, documented most honestly by the coordinator cookbook, is that the comparison is easy to fake: an unconstrained cheap system that simply does less looks cheaper without being better. A credible number is rigor-matched — same task, same tools, same verification bar — which is exactly why the boss/worker/checker case and the cookbook both insist on it, and why the plugin-executor’s unmatched ~60% stays flagged as a hypothesis.

Related

• Cost & Intelligence Levers for Agent Workflows — the broader menu of cost levers; this article zooms in on the delegation-topology lever and maps its four documented shapes with their measured numbers.
• Reward-Hacking and the Verification Frontier — why the checker rung matters: a cheap executor will game a checkable reward, so delegate-down systems need robust, independent verification, not trust.
• The Advisor Strategy · Coordinator-Pattern Cost · Checker · Codex Inside Claude Code — the four source shapes.
• Dynamic Workflows — the Claude Code primitive that runs delegate-down orchestration (the Bun rewrite ran 64 Claudes this way, with two adversarial reviewers per file — a coordinator shape at scale).
• Claude Fable 5 — the frontier model priced at $50/M output that makes minimizing frontier tokens worth engineering around.

Try It

• Name the shape before you build. Decide escalate-up vs delegate-down first (is the work mostly-easy-with-hard-spikes, or mass-decomposable?), then same-vendor vs cross-vendor, then do I have cheap objective ground truth to justify an independent checker?
• Start with the lowest-effort shape that fits. The advisor is a single /v1/messages call with a max_uses cap — no orchestration code — so reach for it before standing up a worker swarm.
• Always build a router. Match task → price tier explicitly; the default “assign the frontier to everything” is the cost blow-up all four articles are reacting to.
• Rigor-match your own savings claim. Before believing any “cheaper” number (including your own), pin the baseline to the same task, tools, and verification bar — or you’re measuring coverage loss, not efficiency.
• Bolt on a re-executing checker for any delegate-down system whose work has a fast pass/fail (build, fetch, diff, accessibility) — it’s the only shape here that structurally contains reward-hacking.

Open Questions

• Do the multiples generalize? Each number is from one task shape (advisor: SWE-bench Pro; coordinator: a 20-fact research question; boss/worker/checker: a website build; plugin-executor: unmeasured). How each ratio moves on long-horizon or fuzzy-ground-truth work is untested. ^[inferred]
• When is escalate-up better than delegate-down for the same task? Both are documented, but no source compares them head-to-head on identical work. ^[inferred]
• Does the cross-vendor shape survive a rigor-matched test? The ~60% figure is unverified; applying the coordinator cookbook’s methodology to Fable-orchestrates-Codex would settle it.