Model Routing for Coding Agents: Cut Cost, Keep Quality

Model routing is the practice of sending each coding task to the cheapest model that can do it well, rather than picking one model at the start of a project and running it for everything. The frontier tier is priced for the hardest reasoning; most of the work a coding agent does is not the hardest reasoning. Paying frontier rates for routine execution is the single most common and most invisible way agentic coding budgets get burned.

The waste is structural, not incidental. Coding output is token-heavy, and output tokens are the expensive half of the meter. Run every feature through Claude Fable 5.1 at $50 per million output tokens and a codebase-full of routine edits, tests, and renames costs the same per token as a genuinely hard cross-cutting refactor, even though Claude Sonnet 5.5, priced 5x lower on output, would have produced identical routine code. The frontier model is not doing anything special on the easy work; you are just paying as if it were.

Routing only works if you know the roster. Both vendors ship a capability ladder, Anthropic in four rungs (frontier, flagship, workhorse, fast) and OpenAI's GPT-6 family in three, and the price gap between top and bottom on output tokens is about 100x on both sides. Verified prices and positioning across both CLIs (AIDEN runs both), as of October 9, 2026 (Claude) and September 30, 2026 (GPT-6):

The prices tell you where each tier earns its place. Claude Fable 5.1 is the frontier: Anthropic's highest-capability model and its recommended step up when Claude Opus 5.5 at higher effort falls short, but $50/MTok out and not Claude Code's default; you select it explicitly. Claude Opus 5.5 is that default, at $20/MTok out. Claude Sonnet 5.5 gives you a 1M window at $10/MTok out and the best Terminal-Bench 4.0 score in Anthropic's launch table (70.6%), the value tier for real work. Claude Haiku 5.5 is the floor at $0.50/MTok out on prompts up to 100K tokens, now with a 1M window of its own, built for sub-agent fan-outs and lint-fix mechanical changes, not complex autonomous coding. On the Codex side the ladder has one rung fewer: GPT-6.1 Sol as the recommended default, GPT-6 Astra for the hardest runs, GPT-6 Luna for cheap volume. Full detail on each is on the models hub, with tier-picking guides for Claude and Codex.

Routing is not just picking a model once per task in isolation, the highest-leverage version is a delegation pattern within a single unit of work. The expensive model does the thinking that is hard to get right; a cheaper model does the typing that is not. Concretely, Fable plans, Codex or Sonnet execute, Fable reviews.

1. 1

   The frontier model plans (spend frontier tokens here)

   Point Claude Fable 5.1 at the codebase and have it draft the spec: files to touch, the approach, acceptance criteria, explicit exclusions. This is exactly where its 1M-token window and Anthropic's highest-capability reasoning pay for themselves, a large-context spec review is a frontier-tier job. It is a small slice of the total tokens and the one place a wrong decision is expensive.
2. 2

   A cheaper model executes (spend most tokens here)

   Hand the approved spec to a workhorse: Claude Sonnet 5.5 on the Claude side, GPT-6.1 Sol on the Codex side, or Claude Haiku 5.5/GPT-6 Luna for genuinely mechanical work. Because the scope is written down, the executor gets a bounded contract, not a vague brief, and a cheaper model with a good spec beats a frontier model with a fuzzy one.
3. 3

   The frontier model reviews (spend a little frontier again)

   Bring the diff back to Claude Fable 5.1 and have it check the implementation against the spec: does it match, did anything out of scope change, do the acceptance criteria hold? The reviewer is not grading its own homework, and reviewing a diff is cheaper than writing it. This closes the loop without paying frontier rates for the bulk execution.

The reason this works is that the token distribution is lopsided. Planning and review are a thin layer of high-value tokens; execution is the thick layer of routine tokens. Routing puts the expensive model only on the thin layers. The same split works one rung down when a feature does not warrant Fable's rate: Claude Opus 5.5, Anthropic's recommended default, plans and reviews while Claude Sonnet 5.5 executes, and Claude Code's opusplan model setting builds exactly that in (Opus in plan mode, Sonnet for execution). The mechanics of running two model families on one repo, branches, worktrees, and the shared spec that acts as the contract, are covered in using Claude Code and Codex together; this article is about which model gets which layer and why.

Here is the routing table in one place. Read it as a starting heuristic tuned to the current roster, not a law, your codebase gets the final vote. The rule underneath every row: escalate a tier when a wrong early step is expensive, drop a tier when the work is bounded and you review it anyway.

Two rows deserve a note. The frontier appears twice, refactors and spec review, because both are reasoning-bound and both are cheap as a share of total tokens; that is precisely the profile you want to spend up on. The fast tier also appears twice, Claude and Codex, because the cheapest model that clears the bar is a fine default for mechanical work regardless of vendor. When both CLIs are in play, route the feature to whichever family fits and let cost break the tie.

The savings claim is easy to hand-wave, so here is a rough, clearly illustrative split using catalog output prices (output dominates coding spend). Assume a feature worth roughly 2M output tokens of agent work: a thin planning-and-review layer and a thick execution layer. Take the split as about 15% planning/review and 85% execution, which matches the lopsided distribution routing exploits.

Illustrative feature ~= 2,000,000 output tokens
(output prices only; verified October 9, 2026)

A) All-frontier (Claude Fable 5.1, $50/MTok out)
   2.0M x $50                         = $100.00

B) Routed (plan/review on Fable, execute on Claude Sonnet 5.5)
   plan+review  0.3M x $50  = $15.00
   execution    1.7M x $10   = $17.00
   total                                   = $32.00

C) Routed to the floor (execute on Claude Haiku 5.5, $0.50/MTok)
   plan+review  0.3M x $50  = $15.00
   execution    1.7M x $0.50 = $0.85
   total                                   = $15.85

Routing execution to Claude Sonnet 5.5 takes the output bill from $100.00 to about $32.00, roughly a 3.1x reduction, and routing the mechanical slice to Claude Haiku 5.5 pushes it near $15.85, close to a 6.3x reduction, all while the planning and review stay on the frontier model. Plan and review on Claude Opus 5.5 instead of Fable and line B drops to $23.00. The exact multiple depends on your token split and ignores input tokens and caching, but the shape is robust: the more of your work is routine, the more routing saves, because you keep frontier rates on the thin layer and pay workhorse or fast rates on the thick one.

Routing is a lever, and like any lever it can be pulled wrong. Three failure modes account for most of the disappointment:

Routing only pays off if switching models is cheap and the handoff is enforced. That is what AIDEN is built for. It is a cockpit over the CLIs you already have, it orchestrates Claude Code and Codex side by side on one spec-first kanban board, BYO inference (your own Claude and Codex subs or keys), local-first, PR-per-feature. Because both CLIs run at once, routing is a per-card choice, not a per-project commitment.

The result is that plan-with-the-expensive-model, execute-with-the-cheap-one stops being a manual juggling act across terminals and becomes the default shape of the board. Assign the planning feature to Claude Fable 5.1, fan the execution features out to Claude Sonnet 5.5 and GPT-6.1 Sol, and review on the frontier again, all in one project. If you are still choosing between the two CLIs, start with Claude Code vs Codex; the routing pattern here assumes you have answered “both.” AIDEN is free for one project and Solo is $20/mo, so you can put a real routed workflow on a board today. And once the window matters as much as the model, pair this with context engineering, the other half of getting good work out of a coding agent cheaply.