A common way to overspend on AI models is to pick the best one once and send everything to it. In 2026 the middle tier costs a fraction of the top one, and the labs themselves say the quality gap is narrowing.
The fix is routing. Send each task to the cheapest tier that does it reliably, escalate when a check fails, and step back down once things settle. This guide gives you the rules, the verified prices and two tools to run your own numbers.
Every major lab sells roughly the same three rungs now. Claude has Opus, Sonnet and Haiku. ChatGPT and the OpenAI API have the GPT-6 family with Astra, Sol and Luna. Google Gemini sells Flash and Flash-Lite below its frontier model. The names change every few weeks. The decision doesn't, so we'll build it around tasks rather than brands.
Three rungs, and the gaps between them are wide
Start with money, because the spread is bigger than most people assume. On the current standard rates, the cheapest and most expensive models listed below differ by a factor of 100 on output tokens. That's the room you're playing in.
The numbers come straight from the vendors' pricing pages. Anthropic lists Opus 5.5 at $4 input and $20 output per million tokens, Sonnet 5.5 at $2 and $10, and Haiku 4.5 at $1 and $5 (Anthropic pricing). OpenAI lists GPT-6 Astra at $10 and $50, GPT-6.1 Sol at $2 and $10, and GPT-6 Luna at $0.10 and $0.50 (OpenAI pricing). Google lists Gemini 3.5 Flash-Lite at $0.30 and $2.50, and its newer Gemini 3.8 Flash at $0.75 and $3.75 on an introductory rate that rises in 2027 (Google AI pricing). Anthropic also sells a premium rung above Opus, Fable 5.1 at $10 and $50, which it recommends for demanding reasoning and long-horizon agent work (Anthropic models overview).
Sonnet 5.5 costs half of Opus 5.5 and a fifth of Fable 5.1. GPT-6.1 Sol costs a fifth of Astra. The budget rungs drop again, and a task that runs a million times a month feels that difference on the first invoice.
What changed in the last ten days
Prices and lineups moved fast, and some advice you'll find online is already stale. Here is the short version, with each claim tied to where it came from.
Anthropic released Claude Opus 5.5 and cut its price. Output tokens now cost $20 per million, down from $25 for the previous Opus (TechCrunch). Anthropic says the model performs at the level of its larger Fable 5.1 on most work and costs 40% less to run than Opus 5 on typical workloads (Anthropic). It also said Sonnet 5.5 and Haiku 5.5 would follow in the coming weeks.
Sonnet 5.5 then arrived. Anthropic calls it significantly cheaper and 30% faster than its predecessor, with a much slower token burn (TechCrunch). Haiku 5.5 hasn't shipped yet, so the Haiku on Anthropic's price list today is still Haiku 4.5.
OpenAI answered the same day Opus 5.5 landed. GPT-6 Sol is pitched at complex tasks including coding, and GPT-6 Luna at high-volume clerical work such as summarizing documents and extracting information (TechCrunch). OpenAI put the API at half the price of the 5.6 series, which it attributes to better caching and inference.
A week later came GPT-6.1 Sol. OpenAI says it nearly matches GPT-6 Astra on agentic coding, computer use and professional work, with an error rate within 1.9% of Astra across reasoning settings (TechCrunch). The price gap is on OpenAI's pricing page: $2 and $10 against Astra's $10 and $50. The same report says OpenAI is not launching GPT-6.1 Astra, and that the Wall Street Journal attributed this to safety concerns from internal testing, including more deception and a tendency to press on without asking permission. The Verge likewise reports OpenAI saying the model was held back over safety worries. Treat the WSJ's specifics as reported, since we couldn't find them in an OpenAI statement.
Google's Gemini 4 Argon is the one to leave off your shortlist. Google announced it but is limiting access to a set of trusted cyber defenders for now (The Verge). You can't route work to a model you can't call.
Why the mid-tier is the default now
The old rule was simple: the flagship is smartest, so use it when quality matters and the cheap one when it doesn't. That rule assumed a big capability gap. The gap is closing from the top down, and the labs are saying so themselves.
Anthropic's own launch post is candid about it. It says that at these capability levels, benchmark margins have become a less reliable guide to real-world differences, and that the gap between Opus 5.5 and Fable 5.1 is narrower than its scores suggest (Anthropic). When the company selling the flagship tells you the margins are fuzzy, believe it.
The sharper claim is about agents. Anthropic's benchmarks show Sonnet 5.5 beating Opus 5.5 on agentic coding, and TechCrunch's guess is that the cheaper model can spawn multiple agents without exceeding cost limits (TechCrunch). Take that with the usual salt, since it's the vendor's own test and the explanation is a reporter's inference. But the mechanism is plausible and you can borrow it. Money buys parallel attempts, and several attempts plus a check often beat one expensive attempt.
That makes the mid-tier a sensible home for coding agents such as Claude Code, Codex in ChatGPT, Cursor, Gemini CLI and GitHub Copilot, where long loops multiply every extra dollar per million tokens. Flagships still earn their keep, but on narrower ground. One counterpoint: Anthropic's own model docs say to start with Opus 5.5 for most workloads and move up to Fable 5.1 only when evals at higher effort fall short (Anthropic models overview). At $4 and $20, Opus 5.5 is no longer priced like a luxury, so treat it as the top of your routine range and test Sonnet 5.5 against it.
Route by volume, complexity, risk and latency
Four questions place almost any task. Ask them in this order and stop when one gives a clear answer.
Volume comes first because it's where the money is. A task that runs thousands of times a day with a clear goal and an easy check belongs on the budget tier. OpenAI describes Luna as built for exactly that kind of work, and Anthropic positions Haiku as its smallest model.
Complexity decides whether the budget tier can cope. Long chains of dependent steps, vague instructions and large codebases push you up to mid-tier. Risk then decides how far up. If a wrong answer costs real money, legal exposure or a customer, the flagship is cheap insurance on that specific call. Latency is the tiebreaker. A person waiting on a live reply may care more about speed than a marginal quality gain, and Anthropic says Sonnet 5.5 runs 30% faster than its predecessor.
The default, escalate, downgrade rule
Turn that into a written policy so nobody argues about it in every pull request.
- Default every new task to the mid-tier.
- Move a task down to the budget tier only when the goal is clear, the volume is high and you can check outputs automatically.
- Move a task up to the flagship tier only when an error is expensive or the mid-tier fails your checks on real examples.
- Review the assignments whenever a lab ships a new tier, which in 2026 means every few weeks.
Escalate on failure, then downgrade when stable
Static assignments go stale. A routing loop fixes that, and it doesn't need much infrastructure. You need a cheap first pass, a way to verify, and a rule for what happens on failure.
Verification is the part teams skip. For structured outputs it's easy: validate the JSON schema, check that extracted fields appear in the source, run the unit tests. For prose it's harder, so sample a small slice for human review and watch the failure rate rather than every output. A model can also grade another model's work, but it's a noisy judge, so use it to flag candidates for a person, not to approve them.
When a check fails, retry once one tier up. Log the failure and the task type. After a stretch of clean runs, try the tier below on a slice of traffic and see if the failure rate holds. This is how you find out, with your own data, which tasks the budget tier actually handles. Vendor benchmarks can't tell you that.
A caveat on cost. Retries cost money too. If more than a small share of cheap-tier calls escalate, you're paying twice and the loop is losing. Track the escalation rate. If it climbs, that task belongs one tier higher permanently.
Where common tasks land
Our placement below is editorial, not a benchmark. It reflects the volume and capability logic above, and you should move any dot your own tests disagree with.
A few specifics are worth spelling out. Tagging, field extraction and summaries are the classic budget jobs, and the labs pitch their cheapest tiers at them. Everyday coding and document drafting sit in the mid-tier. Contract review, architecture decisions and anything where a wrong answer is expensive justify the flagship, though even there you might use it as the reviewer rather than the author.
| Task | Start on | Escalate when | Why |
|---|---|---|---|
| Ticket tagging, labeling | Budget | More than a few percent fail validation | High volume, clear answer, easy check |
| Document summaries | Budget or mid | Summaries miss key facts in spot checks | Low risk per item, big total volume |
| Customer replies | Mid | Tone or policy errors reach customers | Visible mistakes, moderate volume |
| Everyday coding | Mid | Tests fail after two attempts | Mid-tier is the sweet spot for agents |
| Multi-step agents | Mid, with limits | A verification step fails | Parallel attempts under a cost cap |
| Contracts, finance, safety | Flagship | Rarely, add human review instead | Errors are expensive |
Run your own numbers
Here is the arithmetic for one lab, using the Anthropic rates quoted above. Enter what you'd spend with everything on Opus 5.5, then slide work down to Sonnet 5.5 and Haiku 4.5. The spend and the two shares are yours to edit. The rates are fixed, and because Sonnet 5.5 is exactly half of Opus 5.5 on both input and output while Haiku 4.5 is a quarter, the result doesn't depend on your input/output mix.
At the defaults, a team spending $3,600 a month on Opus 5.5 for everything drops to about $2,070 by moving 40% of the work to Sonnet and 30% to Haiku (30% of $3,600 stays at full price, 40% at half, 30% at a quarter). That's a saving of roughly 43%, with the hardest 30% of traffic still on the flagship. Real bills differ because caching, batch discounts and retries all change the math, so treat this as a sizing tool.
If you aren't sure where to start for a specific task, the tree below asks three quick questions.
Seat-based plans change the question
Everything above assumes you pay per token. If your team pays per seat for a chat app or a coding tool, the lab decides the tier for you, and your lever is different. Anthropic raised five-hour usage limits on its Pro, Max, Team and seat-based Enterprise plans alongside the Opus 5.5 launch (Anthropic). In practice, seat users should pick the mid-tier option in the model picker for routine work, save the flagship for the hard sessions, and check how their plan's usage limits treat each model.
If you can't tell which billing model your tools use, our guide to AI tool pricing models walks through credits, seats and tokens. A gateway such as OpenRouter is worth a look when you want one integration that can swap tiers and labs without code changes, since the whole routing idea depends on switching cheaply.
Mistakes that keep the bill high
- Choosing a tier by brand loyalty and never re-testing after a launch.
- Judging a tier on a single hard example instead of a sample of your real traffic.
- Sending long contexts to the flagship when a cheaper model with retrieval would do.
- Skipping caching. Anthropic puts Opus 5.5 cache reads at $0.20 per million tokens, which matters for agent loops that resend the same context.
- Treating vendor benchmarks as a forecast of your own results.
Prompts matter here as well. A well-built prompt lets a cheaper tier clear tasks that a sloppy one pushes upward, and our piece on prompt patterns that survive model updates covers how to keep that work portable. For a wider view of which models exist, see our top AI models and LLMs comparison and the live Top 20 LLMs board. If you mostly want a chat assistant rather than an API, the AI chatbots board and our top AI chatbots guide cover that side, and the AI coding assistants board and coding assistants roundup do the same for developers. If you're weighing running models yourself, local AI vs cloud AI covers when that pays off.
Frequently asked questions
Which AI model should I use if I can only pick one?
Pick the mid-tier of whichever lab your stack already uses. Sonnet 5.5 or GPT-6.1 Sol class models handle the broadest range of work at moderate cost, and you can add a cheaper or stronger tier later where the data justifies it.
Is the flagship ever worth paying for?
Yes, on the narrow set of calls where an error is expensive or where the mid-tier fails your checks on real examples. It is a precision tool, not a default.
Can a mid-tier model beat a flagship?
Anthropic's benchmarks show Sonnet 5.5 ahead of Opus 5.5 on agentic coding. That's a vendor result on one task type, so test it on your own work before moving a critical workflow.
Should I wait for Haiku 5.5 or Gemini 4 Argon?
Don't block on either. Anthropic has said Haiku 5.5 is due in the coming weeks, and Google has limited Argon to trusted cyber defenders for now and hasn't made it generally available. Build the routing layer so a new tier is a config change, then re-run your tests when they ship.
How do I know a cheaper tier is good enough?
Run it on a sample of real inputs, apply an automated check, and compare the failure rate against the tier above. If the gap is small and the task is low risk, downgrade. If failures reach customers, don't.
Do these prices apply to chat subscriptions?
No. They're API rates per million tokens. Chat plans and coding tools bill by seat or usage cap, so the savings come from choosing lighter models for routine sessions.
