The tiers
Every provider ships a lineup along the same axis: raw capability traded against speed and cost. OpenAI and Google have the same ladder under their own names. Think in tiers, not product names — the names change, the tiers don't.
Top tier
e.g. Claude Fable 5.2 · $8 / $40 per million tokens in / out
The hardest reasoning and long, autonomous runs that go for hours.
The most capable, and priced above everything else. For when the flagship is not enough.
Flagship tier
e.g. Claude Opus 5.5 · $4 / $20 per million tokens in / out
Large refactors, subtle bugs, agent loops, novel problems.
Worth it when being wrong is expensive or the work has many steps.
Balanced tier
e.g. Claude Sonnet 5.5 · $2 / $10 per million tokens in / out
Everyday coding, writing, analysis, most chat and app traffic.
The default. Strong quality at half the flagship's price, and faster.
Fast tier
e.g. Claude Haiku 5.5 · $0.10 / $0.50 per million tokens in / out
Classification, extraction, routing, high-volume simple calls.
Cheapest and fastest by a wide margin. Use it anywhere the task is well-defined.
Look at the spread: the top tier costs 80 times what the fast tier does. The gap between tiers has grown, not shrunk — which makes the choice matter more than it used to.
The second dial: effort
Current models think before they answer, and you choose how much. That setting — usually called effort — trades thoroughness against time and tokens within one model. It has largely replaced the old habit of telling a model to "think step by step."
- Low for chat, lookups, and simple transformations.
- Medium to high for everyday coding and analysis.
- The top settings only where you have seen them make a difference — they cost real time and money.
Before building a pipeline that hands easy work to a cheap model and hard work to an expensive one, try the simpler thing: one capable model at lower effort. It is often as good, and it is one less moving part.
By job
| Job | Pick | Why |
|---|---|---|
| Work for hours on a hard, open-ended problem | Top | Long autonomous runs are where the extra capability shows — and where a weaker model drifts. |
| Refactor a large codebase / debug something subtle | Flagship | Deep multi-file reasoning is exactly where this tier earns its cost. |
| Power an autonomous agent loop | Flagship | Tool selection and recovery from mistakes compound — quality pays off. |
| Build a feature in an existing app | Balanced | Strong coding without flagship latency; escalate only if it stalls. |
| Draft and edit long-form writing | Balanced | Good voice and structure; flagship only for high-stakes pieces. |
| Summarize, classify, or tag at volume | Fast | The task is narrow and repeated — pay for speed, not genius. |
| Extract fields from documents into JSON | Fast | Schema-bound work. Use structured output and validate in code. |
| Route a request to the right handler | Fast | A tiny classification call in front of a bigger pipeline. |
| Do the reading for a bigger agent (sub-agents) | Fast | Searching and skimming are cheap work; the lead agent keeps the judgment. |
What will it cost? Work it out
Cost is tokens in × the input price, plus tokens out × the output price. Say a support tool summarizes 2,000 tickets a day; each ticket is about 1,500 tokens and each summary about 200.
Per day: 2,000 × 1,500 = 3.0M tokens in
2,000 × 200 = 0.4M tokens out
Fast 3.0 × $0.10 + 0.4 × $0.50 = $0.50 a day (~$15 a month)
Balanced 3.0 × $2 + 0.4 × $10 = $10 a day (~$300 a month)
Flagship 3.0 × $4 + 0.4 × $20 = $20 a day (~$600 a month)Same job, a forty-fold difference. Whether the cheap one is good enough is not something to guess — it is something to measure, with a small test set. That is what Evals is for. (Thinking counts as output tokens, so higher effort raises the output side.)
Beyond the tier
- Context window — a million tokens is now common, enough for a whole codebase or a stack of long documents. That it fits does not mean you should send it: you pay for every token on every call.
- Tool use & agents — if it will run an agent loop, prefer a model explicitly strong at tool use.
- Latency — user-facing and interactive? A faster tier that feels instant often beats a smarter one that lags.
- Cost at scale — a price gap is irrelevant at 100 calls and decisive at 10 million. Estimate real volume, and judge cost per finished task: a cheap call that needs three retries is not cheap.
- Discounts hiding in the API — caching a prompt prefix you send repeatedly cuts its cost by about 90%, and batch jobs that can wait run at half price. Use both before you downgrade the model.