Fable 5 as the architect, cheaper models as the builders: multi-model coding with predictable costs
The $10 architect and the $2 builders — a worked session with real rates, the three places predictability leaks, and a hard stop you can prove.
Your best model shouldn’t be typing boilerplate.
That’s the whole idea behind the pattern that’s quietly becoming the default way to run coding agents: let a frontier model - Claude Fable 5, with its 1M-token context read the entire repo, write the plan, and review the result, while cheaper models Claude Opus 4.8, or Codex on OpenAI’s side do the fetching, editing, testing, and retrying. Setup guides for Hermes and OpenClaw are already prescribing exactly this split; if your team runs coding agents seriously, some version of it is probably in your dotfiles by autumn.
The pitch is cost-effectiveness. And the pitch is right, below is the math with list prices. But there’s a second promise hiding inside the pattern that almost nobody talks about, and it’s the one that matters to whoever signs the bill: done right, this architecture makes agent costs predictable. Decomposable into parts you can reason about, meterable in numbers you can trust, and cappable at the level where the money actually moves the session.
Here’s the pattern, the real economics, the three places predictability leaks away, and how to plug them with four HTTP headers and one line of YAML.
The pattern in one diagram
The economic logic:
Planning is few, expensive, high-leverage tokens - you want the smartest model and the biggest context exactly once;
Execution is many, cheap, repetitive tokens - the transcript gets re-read on every agentic turn, and 90%+ of that re-reading is served from the prompt cache at a tenth of the price.
What a session actually costs
List prices, per million tokens( actual as for 5th of July, 2026):
A realistic very simple feature-build session - one planning pass over a mid-size repo, two executors working the plan:
Three things to mention:
1. The architect is 65% of the spend on 6% of the calls. That’s not waste - that’s the design. You paid $4.40 for the one artifact that determines whether the other $2.37 produces working code or thirty loops of confident nonsense.
2. The builders are cheap because of the cache. Over half of all input tokens in this session are cache reads at 0.1× the input rate. The marginal executor turn costs about a tenth of a cent-per-thousand-token intuition suggests. This is what makes execution cost linear and boring — exactly what you want.
3. Each part is predictable on its own terms.
Planner cost ≈ repo context × rate, a known quantum per task.
Executor cost ≈ turns × a small, cache-discounted constant.
Decomposable costs are forecastable costs.
One honest footnote: prompt caches don’t cross models. Fable’s cached repo context is not readable by Opus or Codex, each executor builds its own cache on turn one and harvests it for the rest of the session.
Does that pattern always win?
Fabio Akita’s widely-cited three-round benchmark concluded that planner–executor splits are often “premature optimization”: in his tests, solo Opus 4.7 beat every mixed Anthropic combo on quality at comparable cost. It’s a careful benchmark with a public repo, and if your workload looks like his, solo-frontier is a fine answer. Two things his own data also shows: the one decisive economic win in his rounds was a planner–executor split (a high-effort GPT planner with a medium executor came in 80–85% cheaper than solo at near-equal quality), and orchestration paid off exactly where tasks decompose cleanly, which is what large coding tasks increasingly do. But this post doesn’t need the pattern to win the benchmark. If you run multi-model sessions at all, and the tooling ecosystem is pushing you there, the operational questions below hit you regardless of whether your split beats solo Opus by 5% or loses by 5%.
Predictability leaks
I built an AI gateway, watched this traffic all day. Predictability dies in three specific places.
Leak 1: your meter doesn’t understand cached tokens. The two providers report caching in opposite shapes. Anthropic reports cache reads and writes as separate counts - ‘input_tokens’ excludes them. At the same time, OpenAI reports ‘cached_tokens’ as a subset of ‘input_tokens’.
Leak 2: the bill can’t be attributed. The planner spend lands on your Anthropic invoice; the Codex spend lands on OpenAI’s. Two dashboards, two currencies of “usage”, zero concept that these were one piece of work.
Leak 3: nothing stops a runaway session. The industry answer to agent overspend so far is coarse: monthly per-tool caps (Uber’s much-covered $1,500/tool policy), per-user or per-team budgets (OpenAI’s enterprise controls, Cloudflare’s gateway limits). All useful; none match the failure mode. A looping executor doesn’t blow a month — it blows a Tuesday afternoon, spread across two providers so that neither one’s limiter sees the whole picture. To my current knowledge, no popular tool or provider control enforces a budget at the session grain, across providers, with a record of the denial you can hand to finance.
Plugging the leaks: four headers and one line of YAML
This is the part we built. Talon is an open-source (Apache-2.0) gateway: point both tools at it, and every request carries the session identity the pattern already implies.
# planner / executors all send the SAME session id — that's the entire contract
-H "X-Talon-Session-ID: sess-payments-refactor"
-H "X-Talon-Agent-ID: planner" # free-form labels, your names
-H "X-Talon-Parent-Agent-ID: orchestrator" # optional parent linkClaude Code and Codex CLI don’t even need that — their native session/subagent headers are recognized automatically. And the cap is one line on the caller:
olicy_overrides:
max_session_cost: 10.00 # soft cap per coding sessionWhat you get is something like this:
The session becomes one governed unit across both(Anthropic and OpenAI) providers:
Session sess-coding-demo
Requests: 10 (8 allowed, 2 denied, 0 error)
Providers: anthropic, openai
Tokens: in 43 / out 334 / cache-read 14352 / cache-write 840
Cost: €0.012551
Per-agent:
generator 8 req €0.011960
executor ←generator 2 req €0.000591Cache reads metered as cache reads, priced at cache rates, with the pricing basis recorded in the evidence - leak 1 closed. One session, two providers, per-subagent rollup - leak 2 closed.
And when the session hits its cap, it stops, on either provider’s route:
request 6 → HTTP 403
session_budget_exceeded: session spend 0.01 + estimate 0.01 exceeds limit 0.02The denial isn’t a log line — it’s a signed evidence record carrying the exact numbers the decision was made on {limit, spent, estimate}, and the whole session verifies cryptographically:
Session sess-coding-demo: 10 record(s), 10 valid, 0 invalidLeak 3 closed, with a receipt.
Try it in 30 seconds (no API keys)
git clone https://github.com/dativo-io/talon && cd talon
make coding-agents-demo # Docker; fully offline, deterministicThe demo runs the whole story against a deterministic mock that speaks both providers’ wire formats, including streaming and cache tokens. Every figure in this post can be recomputed from it. In a field where the loudest numbers are self-reported savings percentages and anonymous nine-figure invoice anecdotes, we’d rather hand you a demo than an assertion.
What this doesn’t do
Attribution is not authentication. Subagent names are client-asserted labels within an already-authenticated caller. Budgets bind to the caller and session — never to a label an agent could spoof.
The cap is soft. A single in-flight request can overshoot before the next one is denied. Hard reservation is on the roadmap.
Local tools are invisible. Talon governs what crosses it - model and MCP traffic. Your agent’s shell commands run on the developer’s machine.
The takeaway
Use Fable 5 where a million tokens of context and frontier reasoning earn their price: the plan.
Use Opus and Codex where the cache makes tokens nearly free: the execution. That split is genuinely cost-effective — about $6.80 for a session that touches a 400k-token repo across 32 calls. But cost-effective only becomes cost-predictable when the session is a first-class thing: metered with cache-aware honesty, attributed per subagent across providers, and capped with a stop you can prove happened. That’s four HTTP headers and one line of YAML away.
*Talon is open source. The coding-agents guide has the full setup for Claude Code and Codex CLI; the demo leaves you holding the signed evidence.