Jul 2026 · The Watch · Cost Engineering
Model routing: the 68% you’re leaving on the table.
There’s one lever on your AI bill that beats every coupon, credit, or annual discount: use the expensive model to think, and a cheap-but-good model to type. That’s model routing. Here’s the mechanism, the honest math, and how to wire it.
We don’t hide the concept
The whole method is below — take it and run. We build this way ourselves; if you’d rather we map your workflows and wire the routing for you, that’s the service. The pledge stands: we profit from your clarity, not your confusion.
Planning is not the same job as execution.
Almost any AI task splits in two. Planning— figuring out exactly what to do, which pieces are involved, what “good” looks like — is where judgment lives. Pay for the best model here; it’s cheap to do so, because planning reads a lot and writes a little.
Execution— actually producing the output once the plan exists — is where the volume is. A merely-good model, handed a solid plan, does this beautifully. And it’s exactly the phase you do not want to pay frontier prices for, because execution writes a lot.
Scruuge’s TLDR
Best model to plan, good-enough model to execute. You’re not buying “a smarter AI” for the whole job — you’re buying judgment for the 10% that needs it and paying wholesale for the 90% that doesn’t.
Why it works: output tokens cost ~5× input.
This is the part most people miss. On a frontier model, output tokens are roughly five times the price of input tokens (e.g. ~$10 in / ~$50 out per million). Now line that up against the two phases:
- Planning reads, barely writes — lots of cheap input, little expensive output. Frontier price barely stings.
- Execution writes a mountain — that’s where the 5×-expensive output tokens pile up. Frontier price here is the whole bill.
So you spend frontier dollars precisely where output is smallest, and wholesale dollars precisely where output is largest. The pricing structure is begging you to route.
The math, done honestly.
One feature. Frontier at $10 in / $50 out; a good cheap coder at $2 in / $6 out. Realistic token mix: planning is input-heavy, execution is output-heavy.
| Phase (tokens) | All frontier | Routed |
|---|---|---|
| Plan (100k in / 20k out) | $2.00 | $2.00 |
| Execute (150k in / 120k out) | $7.50 | $1.02 |
| Total / feature | $9.50 | $3.02 |
Same plan, same feature, same quality bar — ~68% off, because the cheap model only had to follow the plan, not invent it. Your exact number moves with your token mix; the direction never does. Want yours? Run the calculator.
How to actually wire it — easiest first.
- Copy-paste (zero setup).Plan with the frontier model, ask it for a written spec, paste that spec into a cheaper coding tool: “build this.” Optionally hand the finished work back to the frontier model for one review pass. Crude, and it already banks the majority of the savings.
- Let the harnesses call each other.Claude Code can invoke the Codex CLI (and vice versa) as a shell command — so a small “plan here, delegate execution there” skill runs the loop for you. Two $20–$100 subscriptions routed well outrun one $200 plan used naively.
- Use a routing harness.Model-agnostic tools (Cursor’s auto mode, Factory, Devin) route tasks to a fitting model automatically — Cursor even farms easy sub-tasks to its own cheaper coder while a frontier model drives. Less control, less effort.
- Dedicated routers (enterprise). Services whose entire job is routing (e.g. Not Diamond) — worth it once spend is large, and they often lift quality and cut cost.
Two more dials, not just the model.
Routing isn’t only for coding, and it isn’t only the model name:
- Model family by task. Docs, extraction, and knowledge work have tiers too — a fast cheap model (Haiku-class) handles most of it; reserve the frontier for the genuinely hard call. Don’t just accept whatever’s in the default box.
- Effort / thinking level. Every harness has a low→max reasoning setting and most default to high. “Deploy this code” does not need max thinking. Turning the dial down on simple tasks is free money.
It compounds at scale.
This isn’t a hobbyist trick. Coinbase’s Brian Armstrong has shown their total token usageclimbing while cost stays flat or falls— the gap is routing: cheap (even open-source) models for the bulk of execution, frontier models reserved for planning, plus harder caching and context management on top. Usage up, bill down. That’s the whole game.
One caveat — and it’s important
Route by task, not mid-session. Swapping models inside one long, cached conversation can cost more — you throw away the prompt cache and re-pay for context. So: pick the right model when a task starts, then stay put until it’s done. We wrote the full version of this trap in Tokenmaxxing & the Cache Trap.
Do it yourself — or let Scruuge wire it for you.
You have the whole method. If you’d rather have help deciding which of your tasks are “planning” vs “execution,” picking the right cheap model for each, and setting up the routing so it just runs — that’s the work. Start free: the calculator tells you which tier to switch to; the $999 Assessment maps your routing end-to-end.
Built on a widely-shared model-routing walkthrough; the on-screen arithmetic there was muddled, so the figures above are Scruuge’s clean recomputation of the same worked example. Coinbase figures per Brian Armstrong’s public remarks. Scruuge’s contribution is the honest math, the caveat, and the decision rule — the concept is free; the doing is the service.