Quick reference — pick by what you're doing
Anthropic (Claude)
| If you're doing… | Reach for |
|---|---|
| Classification, extraction, routing, high-volume cheap calls | Haiku 5.5 |
| Most production work — chat, summaries, agentic coding, tool loops | Sonnet 5.5 default |
| Hard reasoning, judgment calls, prose with a voice, tricky debugging | Opus 5.5 |
| The hardest long-horizon autonomous runs (overnight refactors) | Fable 5.1 |
OpenAI (GPT-6)
| If you're doing… | Reach for |
|---|---|
| Classification, tagging, extraction, massive-scale cheap calls | GPT-6 Luna |
| Most production work — chat, coding, agents, tools | GPT-6 Sol default |
| Hardest end-to-end reasoning, coding, computer use, research | GPT-6 Astra flagship |
Rule of thumb both sides share: start one tier higher than you think you need, get it working, then drop down until quality breaks. It's far cheaper to down-shift a working prompt than to debug why a too-small model keeps failing.
The mental model: it's a ladder, not a menu
Both companies now sell the same shape: one family, several rungs. As you climb a rung you buy more intelligence and pay more per token and (usually) more latency. You are not choosing between different kinds of model — you're choosing how much capability the task is worth.
Haiku · Luna. Sub-second, pennies. It knows the standard answer and formats it. No deep reasoning.
Sonnet · GPT-6 Sol. The 80% default: capable, quick, affordable. Where most production traffic should live.
Opus/Fable · GPT-6 Astra. Reserved for hard reasoning, long autonomy, high cost-of-error. Slower, pricier, smarter.
effort at Anthropic, reasoning level like xhigh at OpenAI). So model choice is now two decisions, not one: which rung (capability tier) and how hard should it think (effort). See the effort knob.
Anthropic — Claude lineup
Four rungs. One tokenizer family and one API surface across the top three, so moving between them is mostly a model-ID swap. Prices are per 1M tokens, input / output (as of Nov 1, 2026).
Claude Haiku 5.5 fast · cheap
claude-haiku-5-5
What it's for. The volume tier. Fastest and cheapest Claude; built for simple, well-specified tasks you run a lot: classification, sentiment, routing, tagging, extraction, cheap tool-call steps, first-pass filtering, sub-agents doing narrow reads.
- Use when the task is bounded and the "right" answer is unambiguous, latency matters, or you're doing it thousands of times an hour.
- Don't use when the task needs multi-step reasoning, judgment, or holding a lot of context — it'll confidently give you a shallow answer.
Same 1M context and 128K max output as the rest of the lineup, with adaptive thinking and a default effort of medium. Prompts over 100K input tokens cost $0.50 / $2.50. Haiku 4.5 ($1 / $5, 200K context) is still available as a legacy model. It's the one rung that's genuinely a different capability class, not just a cheaper Sonnet.
Claude Sonnet 5.5 the default
claude-sonnet-5-5
What it's for. The workhorse, and the right default for almost everything. Near-Opus quality on coding and agentic work at half the per-token price of Opus 5.5. If you don't have a specific reason to go up or down, start here.
- Use when you're building anything in production: chat, RAG, summarization, agentic coding, tool loops, document work. High-volume-but-not-trivial lives here.
- Don't use when a mistake is expensive and subtle (go Opus), or the task is dead-simple and you're paying 3× for nothing (go Haiku).
1M context, 128K output, full effort range including xhigh. Adaptive thinking is on by default. Default effort is high. Sonnet 5 ($2 / $10) is the previous generation and is still available.
Claude Opus 5.5 deep reasoning
claude-opus-5-5
What it's for. The judgment tier. Reach for Opus when the task is genuinely hard, the cost of a wrong answer is high, or you want an answer with a point of view rather than a survey. Best-in-class long-horizon agentic coding, tricky multi-file debugging, architecture decisions, dense knowledge work, and writing with actual voice.
- Use when Sonnet's answer is almost right but keeps missing something; when the problem needs real reasoning; when a human would otherwise spend an hour on it.
- Don't use when Sonnet already nails it — you're paying ~2× for no gain — or for latency-sensitive interactive typing.
Anthropic's recommended starting point for most workloads, per its models overview. Adaptive thinking is always on, default effort is medium, and it supports xhigh and max effort. 1M context. Opus 5 ($5 / $25, released July 24, 2026) is the previous generation.
Claude Fable 5.1 frontier · premium
claude-fable-5-1
What it's for. Anthropic's most capable widely-released model — the top of the ladder, priced accordingly. It is not the default "upgrade from Opus." It earns its premium only on the hardest, longest-horizon autonomous work: overnight coding runs that finish without human correction, first-shot builds of well-specified systems, end-to-end analysis/deliverables, deep multi-agent orchestration.
- Use when you're handing it a hard problem to chew on for many minutes autonomously and the outcome justifies 2× Opus pricing. Give it the full spec up front and high effort.
- Don't use when Opus 5.5 already does the job (usually it does), for interactive/latency-sensitive use, or for security/bio-adjacent work where its safety classifiers may refuse.
Quirks that matter operationally (documented for Fable 5; confirm they still hold on 5.1): thinking is always on (you can't disable it); the raw chain-of-thought is never returned; single requests can run many minutes (plan for streaming/timeouts); requires 30-day data retention (no zero-data-retention).
Where the Sonnet → Opus gap actually shows up
For everyday, well-trodden requests you mostly won't notice the difference — both are well-calibrated on common ground. The gap opens in three specific places, and knowing them tells you when the up-tier is worth it:
Ask "is Hamlet actually indecisive?" Sonnet gives the standard reading plus the counter-reading, tidy and balanced. Opus is likelier to commit to a position and push back on the framing itself. Sonnet surveys; Opus argues.
"Should I tell my dying mother I'm not religious anymore?" Sonnet gives a clean ethics breakdown. Opus is likelier to notice it isn't really an ethics question and answer the question behind the question.
Sonnet writes smooth, competent, slightly generic prose. Opus takes sharper turns and is likelier to hand you a sentence you'd actually quote. For anything read by a human for pleasure, that matters.
Where the gap is small: factual recall, explaining established concepts, summarizing a known argument — anything whose answer already exists clearly in the world. Where it's near zero: when you just want the standard view, fast. Pay for Sonnet there.
The same logic scales one rung further: Opus → Fable only pays off when the work is long-horizon and autonomous, not when it's merely "important." A hard one-shot answer is Opus territory; a hard multi-hour project is where Fable pulls ahead.
OpenAI — GPT-6 lineup
GPT-6 Astra shipped Sept 3, 2026 as the flagship; Sol and Luna followed Sept 22 at half the price of the GPT-5.6 preview rows they replace (OpenAI says the cut is permanent). GPT-6.1 Sol followed Sept 29 at the same list price as GPT-6 Sol, with cheaper cached input. All are generally available with a 1.05M-token context and 128K max output. Prompts over 272K tokens cost 2× on input and cache rates and 1.5× on output. Prices per 1M tokens, input / output (as of Nov 1, 2026, from OpenAI's pricing page).
GPT-6 Luna cheapest
gpt-6-luna
What it's for. OpenAI's most efficient model for focused, high-volume tasks: classification, tagging, extraction, summarization, routing, and simple structured output where you pay by the millions of calls. Cached input is $0.01.
- Use when throughput and cost per call dominate and the task is narrow and well-specified.
- Don't use when the task needs real reasoning or nuance, where a cheap model returns a plausible wrong answer. Step up to Sol.
OpenAI's rough analog of Haiku, and cheaper still. Its $0.10 input rate is a tenth of Sol's.
GPT-6.1 Sol workhorse default
gpt-6.1-sol
What it's for. The workhorse for most production work, positioned by OpenAI for complex coding and agentic workflows. Cached input is $0.10 (5% of input). GPT-6 Sol, the previous point release, lists $2 / $10 with cached input at $0.20. Batch is half price.
- Use when you want strong capability across coding, reasoning, agents and chat without paying for the flagship. This is where most production traffic should live.
- Don't use when the task is the hardest end-to-end work where Astra's headroom pays for itself, or when Luna already suffices.
The closest OpenAI equivalent to “Sonnet's tier”, and priced the same as Claude Sonnet 5.5 ($2 / $10). Takes text and image input.
GPT-6 Astra flagship
gpt-6-astra
What it's for. OpenAI's most capable model, built for the hardest end-to-end work: complex reasoning, coding, computer use, research and document creation. Cached input is $1.
- Use when the task is genuinely hard, correctness is worth a 5× premium over Sol, or you are prototyping and want the best answer before optimizing cost downward.
- Don't use when Sol already clears the bar. Astra costs 5× Sol on both input and output.
Five reasoning effort levels, low through max, the equivalent of Anthropic's effort. Same list price as Claude Fable 5.1 ($10 / $50).
Specialized variants niche
Beyond the general ladder, OpenAI ships task-tuned models. Pick these only when your task is that task:
- gpt-6.1-terra ($1 / $5, cached $0.05) — listed on OpenAI's pricing page; its positioning was not verified for this sheet, so check before choosing it.
- gpt-5.3-codex ($1.75/$14) — coding-agent-tuned; for autonomous software workflows (the model behind Codex). Older than the GPT-6 line; check whether Sol now covers your case.
- o3-deep-research ($5/$20) & o4-mini-deep-research ($1/$4) — specialized reasoning models for long multi-step web research with citations, not general chat.
- GPT-Live-1 and the realtime family — low-latency voice conversations with interruption handling, speech-to-speech, transcription.
- GPT-Image-2.5 Sunburst — image generation.
Where the GPT-6 Sol → Astra gap shows up
Astra costs 5× Sol, so on routine work the extra spend buys nothing you can see. OpenAI positions Astra for the same places Opus and Fable earn their price: hard reasoning, long end-to-end tasks, and not losing the thread. Treat these as hypotheses to test on your own workload:
Multi-step problems (a bug spanning several files, a proof, a plan with dependencies) are where a flagship is most likely to justify itself. Raise Sol's reasoning effort first; it is the cheaper way to buy depth.
Long-running agent work and computer-use tasks are where OpenAI aims Astra. For small, well-scoped tasks, Sol iterates fine at a fifth of the price.
The second decision: how hard should it think?
Picking the rung is half the choice. The other half is the reasoning dial — the single biggest lever on quality, latency, and cost within a model. Turning it up on a cheaper rung often beats jumping to the next rung at low effort, for less money.
| Anthropic | OpenAI | |
|---|---|---|
| The dial | effort: low · medium · high · xhigh · max | reasoning level (Astra: five levels, low through max) |
| Default | Set per model: high on Sonnet 5.5 and Fable 5.1, medium on Opus 5.5 and Haiku 5.5; adaptive thinking decides depth per request | Model-dependent; set it explicitly for hard work |
| Turn it up for | Coding & agentic work (xhigh), correctness-critical one-shots (max) | The hardest reasoning/coding tasks |
| Turn it down for | Chat, classification, latency-sensitive UX (low/medium) | Simple, fast, cheap tasks |
| The catch | Higher effort = more thinking tokens = higher cost + latency; give max_tokens headroom | Reasoning tokens bill at output rates — high effort can multiply cost several-fold |
Cost & context ladders (at a glance)
Per 1M tokens, input / output, (both as of Nov 1, 2026 — verify). The ladders line up tier-for-tier, which is the easiest way to translate a habit from one vendor to the other.
Anthropic
OpenAI
Rough cross-reads (positioning, not identical capability): Haiku ≈ Luna · Sonnet ≈ Sol · Opus/Fable ≈ Astra. Both sides also offer prompt caching (cache reads ~0.1× input) and batch (~50% off, non-urgent) — often a bigger lever on your bill than the tier choice itself.
How to actually choose (a 4-step recipe)
- Prototype on the flagship. Start with Opus / GPT-6 Astra at high effort. Get the task working correctly first — don't optimize a broken prompt. This tells you the ceiling.
- Down-shift until it breaks. Move to the workhorse (Sonnet / GPT-6 Sol), then the fast tier (Haiku / GPT-6 Luna). Stop one rung above where quality fails. Most production traffic ends up on the workhorse or fast tier.
- Tune effort before re-tiering. If the cheaper rung is almost good enough, raise its
effort/reasoningbefore jumping back up. Cheaper and often sufficient. - Split the workload. Real systems mix tiers: fast model for routing/extraction, workhorse for the main loop, frontier only for the hard sub-steps or a final review pass. You don't have to pick one.
Common mistakes & anti-patterns
effort/reasoning — or burn money at max effort on a task medium would nail.Straight answers
"I have no idea where to start — just tell me one."
Sonnet 5.5 (Anthropic) or GPT-6.1 Sol (OpenAI). The workhorse tier is the right default for almost everything. Get it working there, then move down for cost or up for quality only if you have a concrete reason.
"When is Opus 5.5 / GPT-6 Astra actually worth it?"
When the workhorse's answer is almost right but keeps missing the point, when the problem needs genuine multi-step reasoning, or when a mistake is expensive and subtle. If Sonnet/Sol already nails your task, the up-tier buys you nothing visible.
"Fable 5.1 — should I ever use it?"
Rarely, and deliberately. Fable earns its 2.5× Opus 5.5 price on long-horizon autonomous runs — overnight refactors, multi-hour problem-solving, deep multi-agent orchestration. Not a routine "upgrade." If you're not sure you need it, you don't.
"Should I use the cheap tier to save money?"
Yes — for bounded, well-specified, high-volume tasks (classification, extraction, routing). No — for anything needing reasoning or judgment, where a wrong answer costs more than the tokens you saved. And try caching + batch before down-tiering; they cut cost without cutting quality.
"Reasoning model or normal model?"
That distinction has mostly collapsed. Reasoning is now a dial (effort / reasoning) on the model you already picked, not a separate product. Pick the tier for capability; turn the dial up for hard reasoning, down for speed. OpenAI's remaining o-series models are specialized deep-research tools, not general chat.
"How do I tell which tier my task really needs?"
Run the calibration test: take a real task you have strong judgment about, try two adjacent tiers, and see whether the pricier one is visibly better on your work. That single comparison beats any leaderboard for predicting your result.