Model routing cheat sheet

Stop asking which model is best. Ask which one to hire.

"Which model is best" is the wrong question, the same way "who is the best employee" is the wrong question. Best at what, for how much? Claude Opus 4.8 tops the mid-2026 coding benchmarks and costs $5/$25. Gemini 3.1 Flash-Lite costs $0.25/$1.50 and will happily classify 10,000 support tickets while Opus is still clearing its throat. Neither is "best." They have different salaries and different jobs.

The meta-finding repeated across every serious mid-2026 comparison: no single model wins every lane. Heavy devs who route by task spend $20 to $200 a month. Heavy devs who run the flagship on everything spend $1,000+. Same output, 5 to 10x price difference. Routing is the highest-ROI skill nobody teaches.

The routing table: 9 job types, one hire each

This is the core of the sheet. Cost bands are my estimates from typical session token volumes with caching on; your mileage varies with context size. When two models are listed, the first is the default.

The price sheet: July 2026, all three vendors

Anthropic (per 1M tokens)

Modifiers: prompt-cache reads cost ~0.1x input, cache writes 1.25x (5-min TTL) or 2x (1-hr TTL), Batch API is 50% off. No long-context premium on Opus 4.8: the full 1M window bills at standard rates.

OpenAI (per 1M tokens)

Modifiers: cached input at ~10% of input price, automatic. Batch endpoint 50% off (GPT-5.5 drops to $2.50/$15 batched).

Google Gemini (per 1M tokens)

Modifiers: Batch mode 50% off all models (up to 24h turnaround), cached input at ~10% of the cache-miss rate on Pro and Flash. The rate-limited free API tier is still generous, which makes Gemini the cheapest place to prototype a bulk pipeline before you pay anyone.

Subscription math: when $20/$100/$200 beats API keys

The flat plans are usage arbitrage. If your usage is steady and heavy, the vendor loses money on you and that is the point. If your usage is spiky or light, you are the one subsidizing the heavy users. Here are the plans, then the break-evens.

Break-even, real numbers

Working assumption: Sonnet 5 as the daily driver, and a typical 2-hour Claude Code session burning roughly $3 to $8 in API-equivalent tokens (estimated, cache-assisted). From there:

1. 1

   $20 Pro pays for itself after 3 to 6 sessions a month

   One afternoon a week of Claude Code and the sub already wins. This is the easiest yes in the whole sheet: if you code with AI at all, the $20 tier is close to free money.

2. 2

   $100 Max 5x breaks even around $100/mo of API-equivalent usage

   That's daily Sonnet sessions, or a few Opus agent runs a week. Reference point: metered Codex heavy-dev spend runs $100 to $200/mo, so a flat $100 on the Claude side is a genuine discount at the same intensity.

3. 3

   $200 Max 20x is for Opus-heavy daily agent work

   API-metered equivalents run $500 to $1,000+/mo for heavy agentic users. If your agents run while you sleep, the $200 plan is the cheap option. Strange sentence, true in 2026.

4. 4

   Set the overflow cap on day one

   New in 2026: Claude Pro/Max overflow "usage credits" continue at API rates after your plan limit, with a monthly cap you set. Set the cap before you need it, not after the surprise invoice.

When API keys still win

• [ ]Spiky usage: heavy one week, zero the next. Subs charge you for the zero weeks.
• [ ]Bulk jobs: the Batch API's 50% discount has no subscription equivalent.
• [ ]Multi-provider routing: subs lock you into one vendor's models; the routing table above wants at least two vendors.
• [ ]Anything production or user-facing: never serve users off your personal sub. Rate limits, ToS, and your own usage all collide.

The downgrade ladder: start expensive, hand off cheap

The single most expensive routing mistake is symmetric: people either run Opus on everything (burning money) or run the cheap model on everything (burning time on rescue work). The fix is a ladder. The expensive model establishes the pattern once; the cheap model copies it forever.

1. 1

   Tier 1: Opus 4.8 (or Fable 5) sets the pattern

   Architecture, the first vertical slice, CLAUDE.md conventions, the hard first version of every pattern. This is where judgment matters and where the $25/M output tokens buy something real.

2. 2

   Tier 2: Sonnet 5 grinds the pattern out

   Everything that now has an example to copy: more endpoints shaped like the first endpoint, more components shaped like the first component, tests shaped like existing tests. This is 70% of a project's tokens at 40% of the price.

3. 3

   Tier 3: Haiku 4.5 / Flash-Lite / 5.4 nano do the mechanical bulk

   Renames, data cleanup, classification, subagent grunt work. Nothing at this tier should require judgment; if it does, it's mis-routed.

4. 4

   Escalate back up only after 2 failed attempts

   Two strikes at the current tier, then move one tier up with a fresh context. Do not let a cheap model retry itself into a hole; its failed attempts poison the context for attempt three.

The ladder only works if the cheap model inherits the context. It won't have the expensive model's reasoning history, so you make the expensive model write it down before you switch. Run this on the expensive model as the last act of its session:

You are ending a session. A cheaper, less capable model will continue this
work and it will NOT have your reasoning history. Write a handoff brief it
can follow mechanically.

Project: [PROJECT NAME AND ONE-LINE DESCRIPTION]
Work completed this session: [WHAT YOU JUST BUILT]
Remaining work to hand off: [THE ROUTINE TASKS LEFT]

Produce a single markdown file with exactly these sections:

## Pattern to copy
The ONE canonical example of the established pattern, with the file path
and the actual code. If there are multiple patterns, one example each.

## Rules that are not obvious from the code
Every convention I would enforce in review: naming, error handling, where
files go, what to import from where. Bullet list, imperative voice.

## Task list
The remaining tasks as a numbered checklist. Each task: file(s) to touch,
which pattern from above to copy, and a one-line acceptance check.

## Do not touch
Files and behaviors that must not change, with one line on why each is
fragile.

## When to stop and escalate
3 to 5 concrete tripwires (e.g. "any change to the auth middleware",
"test suite fails twice in a row") where the cheaper model must stop and
report instead of improvising.

Constraints: no motivational filler, no restating the project pitch.
Assume the reader executes instructions literally and has zero context
beyond this file. Under 800 words.

Save the output as HANDOFF.md, then open the cheap session with exactly: "Read HANDOFF.md, then start task 1." The tripwires section is the part people skip and regret; it's what stops a $1/M model from improvising a rewrite of your auth middleware at 2am.

Cost control: 9 tactics, checkable

• [ ]Cache-friendly prompts: system prompt and stable context at the TOP, variable stuff last. Cache hits need identical prefixes, and reads bill at ~0.1x input.
• [ ]Never edit the top of a long conversation. It invalidates the cache for everything after it, and you re-pay full input price on the whole history.
• [ ]Small contexts: point the agent at 5 relevant files, not the repo. On Gemini 3.1 Pro specifically, stay under 200K input or the rate doubles to $4.
• [ ]Kill loops early: an agent that failed the same test 3 times is not about to succeed on attempt 7. Stop, escalate a tier or fix it yourself.
• [ ]Review the plan before any long autonomous run. 10 minutes of plan review is cheaper than $40 of confidently wrong Opus tokens.
• [ ]Batch anything that can wait 24h: 50% off on Anthropic, OpenAI, and Gemini. The single biggest lever for bulk work.
• [ ]On reasoning models, watch billed tokens, not visible tokens. o-series hidden reasoning runs 3 to 10x what you see on screen.
• [ ]Set the overflow usage-credit cap on Claude Pro/Max before you hit the plan limit.
• [ ]Re-check this sheet monthly. Sonnet 5 intro pricing ends 2026-08-31, GPT-5.6 is preview pricing, and o3 just took a price cut. This market reprices faster than cloud ever did.

Per-tool notes: plan quirks that change the math

The routing logic above is tool-agnostic, but each tool's billing has quirks that shift what "cheap" means inside it. The four I get asked about most:

Take the sheet with you

The whole cheat sheet as a single markdown file: routing table, price sheet, subscription math, the handoff prompt, and the cost-control checklist. Drop it in your repo or your notes app, and re-verify the prices monthly (the LAST VERIFIED date is at the top of the file for exactly that reason).