TL;DR: Sonnet 4.6 ($3/$15 per million tokens) is the default for most work. Opus 4.8 ($5/$25) earns its price on long autonomous tasks. Fable 5 ($10/$50) is for the hardest jobs only. The skill is routing, not picking the biggest.
Claude has three premium tiers in mid-2026. Sonnet 4.6 is the everyday balance of speed and smarts at $3 input and $15 output per million tokens. Opus 4.8 is the most capable Opus-tier model at $5 and $25. Fable 5 sits on top as the most powerful model Anthropic makes, at $10 and $50. All three read a 1M token context window. The hard part is not knowing the prices. It is knowing when the jump in price buys you a real jump in value.
Key takeaways
- Three premium tiers: Sonnet 4.6 ($3/$15), Opus 4.8 ($5/$25), Fable 5 ($10/$50). All have a 1M context window.
- On a sample 100M-in, 50M-out month, the bill runs $1,050 on Sonnet, $1,750 on Opus, and $3,500 on Fable.
- Sonnet 4.6 is the right default for roughly 80% of production work. Step up only for hard or long tasks.
- Opus and Fable reach 128K max output and run for hours. Fable’s thinking is always on, so single turns can take minutes.
- The model is the easy part. Routing, caching, and effort tuning are the skills that separate a strong AI engineer from an average one.
The three premium tiers at a glance
Here is the head-to-head, with the exact model ID your engineers will type into the API. Use this as your reference. Everything below explains when each one is the right call.
| Model | Model ID | Context | Max output | Price in / out (per 1M) | Best for |
|---|---|---|---|---|---|
| Sonnet 4.6 | claude-sonnet-4-6 | 1M | 64K | $3 / $15 | The default for most production work |
| Opus 4.8 | claude-opus-4-8 | 1M | 128K | $5 / $25 | Long agentic work, big refactors, deep research |
| Fable 5 | claude-fable-5 | 1M | 128K | $10 / $50 | The hardest reasoning and the highest-stakes work |
Which tier fits your next build?
Pick the job you have in mind to see the right model.
For daily coding, code review, extraction, and tool use, Sonnet is the balance pick at $3/$15. It handles most work at a fair price. Pair it with engineers who build with it daily. Hire AI agent developers who ship on Claude.
For week-long refactors and agents that run for hours, Opus is highly autonomous and worth the step up to $5/$25. Strong AI and machine learning engineers get the most from it.
For the hardest reasoning where a wrong answer is costly, Fable 5 is the most powerful model at $10/$50. Keep it for the small share of work that truly needs it, and route the rest down.
The model is the easy part. The hard part is the team that builds and ships with it. We match you with pre-vetted engineers in about 24 hours. Tell us what you need.
The real question is marginal value
The price ladder is steep. Sonnet to Opus is a 67% jump on output. Opus to Fable 5 doubles it again. So the question is never “which model is best.” The best model is whichever one returns the right answer for the least money. You only pay up when the cheaper tier fails the task.
For most jobs, Sonnet 4.6 is already good enough. It writes solid code, reviews pull requests, summarizes long documents, and drives tools well. Opus and Fable 5 pull ahead on depth and stamina, not on basic skill. They think longer, hold a plan across many steps, and recover from their own mistakes on tasks that run for hours. That is what you are buying at the top of the ladder.
A good rule sounds simple but is rarely followed. Default to the cheapest tier that does the job, add a quick check, and escalate only the cases that fail. We worked with a fintech team that ran every request on the top tier out of habit. Moving routine work to Sonnet and keeping the top model for a thin slice of hard cases cut their bill by more than half with no drop in quality.
What the price gap looks like in a real month
Per-million prices are abstract. A monthly bill is not. Take a moderately busy product that reads 100 million input tokens and writes 50 million output tokens a month. The chart below shows the all-in model bill on each tier for that exact workload.
The same work costs $1,050 on Sonnet, $1,750 on Opus, and $3,500 on Fable 5. Output is the driver, since most apps read a short prompt and write a longer answer. Two levers shrink any of these bills. Prompt caching stores a large fixed prompt once and reuses it at about a tenth of the input price. Batch processing runs non-urgent jobs at half price. A team that uses both serves heavy workloads for far less than the sticker rate suggests.
The biggest savings come from routing, not from picking one model and sticking with it. A common pattern is to send every request to Sonnet first, run a cheap check on the result, and only escalate the ones that fail to Opus or Fable. Most requests never escalate, so you pay the top rate on a small slice of traffic instead of all of it. Build that one routing layer well and the model bill often falls by 60% or more, with the same quality the customer sees.
Sonnet 4.6: the default that handles most work
Sonnet 4.6 is the best mix of speed and intelligence in the lineup. It has a 1M token context window, which is roughly 750,000 words, enough to drop a whole codebase or a stack of documents into one request. Its max output is 64K tokens. At $3 input and $15 output, it is the tier we tell most clients to start on.
Sonnet is fast, which matters for anything a user waits on. Chat, code completion, review, and live tools all feel snappy on it. It supports adaptive thinking, so you can let the model decide how deep to reason, and you steer cost with an effort setting from low up to max. For interactive products, Sonnet at low or medium effort is often the sweet spot. Our breakdown of Claude versus ChatGPT for coding goes deeper on where it lands against the field.
Opus 4.8: for long, autonomous work
Opus 4.8 is the most capable Opus-tier model and the natural step up from Sonnet. It is highly autonomous and built for long, multi-step work that runs for hours. Big code migrations, deep research, and agents that keep their own memory across a task are where it shines. It has a 1M context window and a larger 128K max output, at $5 input and $25 output.
Two Opus features matter for agent builders. It supports an extra effort level called xhigh, which sits between high and max and is the recommended setting for hard coding and agent work. It also accepts mid-session system messages, so your app can hand the model new context partway through a long run without breaking its cache. These are the levers a skilled engineer reaches for. They are also the kind of thing we check when we vet candidates.
Fable 5: for the hardest jobs only
Fable 5 is the most powerful and most intelligent model Anthropic offers. It shares the 1M context window and 128K max output with Opus 4.8, but it is built for the hardest reasoning and the longest autonomous runs. Reach for it when the task is the toughest you have and the cost of a wrong answer is high. For most teams, that is a small share of total work, not the daily driver.
Fable behaves differently in ways your team must plan for. Its thinking is always on, so a single request on a hard task can run for many minutes. You need streaming, sensible timeouts, and a progress indicator, not a blocking call that hangs your UI. The raw chain of thought is never returned, only a summary if you ask for one. Fable also requires 30-day data retention, so it will not run for an organization set to zero data retention. Give it a clear, full task up front and let it work.
The API differences that trip teams up
All three tiers share the same core skills. Every one reads images, calls tools, runs code in a sandbox, and returns strict JSON when you ask for it. The gaps are in the request shape, and a few of them break code that worked on older models. Knowing these saves a painful debugging session.
Three changes catch teams out most. Fixed thinking budgets are gone across all three, replaced by adaptive thinking plus an effort setting, so old budget code returns an error. Assistant message prefills no longer work on these models, so use structured outputs or a system instruction to shape the reply instead. And Fable 5 can return a refusal as a normal response, which your code should check before reading the content, with a fallback model ready to retry. The table sums up the request-shape differences.
| Behavior | Sonnet 4.6 | Opus 4.8 | Fable 5 |
|---|---|---|---|
| Thinking control | Adaptive + effort | Adaptive + effort | Always on + effort |
| Effort levels | low to max | low to max (incl. xhigh) | low to max (incl. xhigh) |
| Assistant prefill | Not supported | Not supported | Not supported |
| Mid-session system message | No | Yes | No |
| Typical single-turn time | Fast | Medium to long | Long, minutes on hard tasks |
| Data retention | Standard | Standard | 30-day required |
Caching has a catch worth knowing too. The cache is tied to one model, so the moment you switch tiers mid-conversation you lose the cached prefix and pay full price to build it again. This is one more reason routing should happen at the start of a request, not in the middle of a running session. A team that swaps models on every turn quietly throws away most of its caching savings.
One more practical note. Opus and Fable can write up to 128K tokens in a single reply, but you must stream those long outputs or the request can time out. This is a common cause of broken long-generation jobs. The current Anthropic models overview lists every active model ID and limit in one place, so check it before you build or migrate.
How to choose, fast
Two questions settle most decisions. How hard is the task, and how tight is the budget. Plot those two and the right tier falls out. Easy work stays on Sonnet no matter the budget. Hard work under budget pressure goes to Opus. Only the hardest work with cost no object justifies Fable 5.
The table below maps common jobs to a tier so you can decide in seconds. Notice how much sits on Sonnet. That is by design. The cheaper tier is the right answer far more often than teams assume.
| Job | Recommended tier | Why |
|---|---|---|
| Daily coding and code review | Sonnet 4.6 | Strong balance of speed and skill |
| Document summaries, extraction | Sonnet 4.6 | 1M context, good accuracy, fair price |
| Customer-facing chat and tools | Sonnet 4.6 | Fast responses at a sane cost |
| Large refactor, multi-hour agent run | Opus 4.8 | Highly autonomous over long tasks |
| Deep research with its own memory | Opus 4.8 | Holds a plan across many steps |
| Hardest reasoning, high stakes | Fable 5 | Most powerful, worth the premium |
What this means for hiring
Knowing the three tiers is step one. Getting value from them is the harder step. The teams that win are not the ones running the biggest model on everything. They are the ones who route work to the right tier, cache context, set effort well, and ship a clean product around it. That is engineering, not a model choice.
Strong AI engineers are scarce and costly in the United States. A senior AI engineer there runs $12,000 to $18,000 per month all in. The same skill from a pre-vetted engineer in Vietnam or the Philippines often costs $3,000 to $6,000 per month. The work is the same. The bill is not. Our Vietnam versus US developer cost breakdown shows the full math, and you can size any role on our developer rate card.
If you want the wider market picture, our Claude AI statistics for 2026 covers adoption, revenue, and share. Read it to see how fast this market is moving and why the right team matters more each quarter. The model lineup will keep changing. The need for engineers who use it well will not.
Build your Claude stack with the right team
Claude gives you three premium tiers and clear prices. The choice between them is easy once you match the model to the job. The team that builds with them is what ships value. We match you with pre-vetted senior engineers across Asia in about 24 hours, with no upfront cost and payroll handled.
