Sonnet 5 vs Opus 4.8 vs Fable 5: A Cost-Per-Task Comparison
Picking a model by "the smartest one" ignores that per-task cost can differ by an order of magnitude between Sonnet 5, Opus 4.8, and Fable 5 for work that any of the three could plausibly handle.
This page walks through the headline pricing, then works that pricing through a handful of realistic task shapes, so the decision is grounded in dollars per task, not just a vague sense of "quality."
How to Use This Comparison
- Start from the headline per-MTok table, then estimate the token shape (short input/long output, or long input/short output) of your actual task.
- Multiply, don't eyeball, small per-token gaps compound fast at volume.
- Re-run the math whenever a model's pricing changes, Sonnet 5's intro pricing in particular is time-boxed and will change on 2026-08-31.
- Treat Haiku 4.5 as the implicit fourth option, it isn't compared task-for-task here since this page focuses on Sonnet/Opus/Fable, but it's often the right answer for the simplest task shapes covered below.
- Revisit this comparison whenever you add a new task type to your product, cost shape varies enormously by task.
Headline Pricing
| Model | Input / MTok | Output / MTok | Positioning |
|---|---|---|---|
| Claude Sonnet 5 | ~$2 (intro, through 2026-08-31, then ~$3) | ~$10 (intro, then ~$15) | Default, balanced cost/capability |
| Claude Opus 4.8 | ~$5 | ~$25 | Stronger reasoning, higher cost |
| Claude Fable 5 | ~$10 | ~$50 | Top tier, highest cost |
Opus 4.8 is roughly 2.5x Sonnet 5's intro input rate and 2.5x its output rate. Fable 5 is roughly 5x Sonnet 5's intro rates on both sides, and roughly 2x Opus 4.8's rates on both sides. The ratios between the three stay consistent across input and output, so a task's relative cost across models doesn't shift much based on whether it's input-heavy or output-heavy, it's the same multiplier either way.
Decision 1: A Short Classification-Style Prompt
Scenario: Tag a support ticket with one of eight categories. Input is short (~200 tokens including a brief taxonomy), output is a single word (~5 tokens).
| Rank | Choice | Approach |
|---|---|---|
| Best | Sonnet 5 | More than sufficient reasoning depth for an eight-way classification; cost is negligible at this size regardless of tier |
| 2nd | Opus 4.8 | Works fine but the extra cost buys nothing measurable for a task this simple |
| 3rd | Fable 5 | Correct answer, wasted spend; the task doesn't exercise the extra capability |
Wrong choice: Reaching for Fable 5 "to be safe" on a task this small. At ~200 input and ~5 output tokens, even Fable 5's cost per call is a fraction of a cent, so the dollar difference per call is tiny, but it compounds badly at high volume and sets a bad default for the next, larger task.
Why best is best: The task has almost no reasoning depth requirement, so the differentiator is per-call overhead at scale, not per-call correctness. Note that Haiku 4.5 would be worth evaluating here too if volume is high, this comparison sticks to Sonnet/Opus/Fable per its scope.
Decision 2: Summarizing a Long Document
Scenario: Summarize a 20-page internal report (~15,000 input tokens) into a 300-token executive summary.
| Rank | Choice | Approach |
|---|---|---|
| Best | Sonnet 5 | Handles long-document summarization well; the task is input-heavy, which is where Sonnet's lower input rate matters most |
| 2nd | Opus 4.8 | Justified if the report has dense, ambiguous, or technical content where synthesis quality is genuinely at risk |
| 3rd | Fable 5 | Rarely justified for straightforward summarization; the input-heavy shape makes the 5x input multiplier expensive fast |
Wrong choice: Defaulting to Opus or Fable purely because the document is long. Document length drives token count, not reasoning difficulty, those are two different axes and only one of them (difficulty) should drive model choice.
Why best is best: At 15,000 input tokens, the input-side cost gap between Sonnet 5 and Fable 5 is roughly 5x on the dominant token category for this task shape, and summarization quality differences between the tiers are usually marginal for well-structured source documents.
Decision 3: Multi-Step Reasoning Over Ambiguous Requirements
Scenario: Turn a vague, three-paragraph feature request into a structured technical design with trade-offs called out (~800 input tokens, ~1,500 output tokens).
| Rank | Choice | Approach |
|---|---|---|
| Best | Opus 4.8 | The task genuinely requires weighing trade-offs and filling gaps in underspecified requirements, where the stronger tier earns its premium |
| 2nd | Fable 5 | A defensible upgrade for the highest-stakes design decisions, where a wrong trade-off call is expensive to unwind later |
| 3rd | Sonnet 5 | Can produce a reasonable first draft but is more likely to need a human pass to catch missed edge cases in ambiguous requirements |
Wrong choice: Staying on Sonnet 5 "by default" for every design task regardless of ambiguity. A cheap draft that misses a load-bearing trade-off and has to be redone costs more in engineer time than the model tier premium would have.
Why best is best: This is exactly the task shape, genuine multi-step reasoning under ambiguity, where paying roughly 2.5x Sonnet's rate for Opus is buying something real rather than margin padding.
Decision 4: High-Volume, Low-Stakes Content Generation
Scenario: Generate 10,000 short product description variants per day (~150 input tokens, ~100 output tokens each).
| Rank | Choice | Approach |
|---|---|---|
| Best | Sonnet 5 | Quality is more than adequate for short, templated generation, and this task shape is exactly where per-call cost multiplies into a real budget line at 10,000 calls/day |
| 2nd | Opus 4.8 | A defensible choice if brand voice consistency across variants has proven to be a real problem at Sonnet tier |
| 3rd | Fable 5 | Cost multiplier makes this the most expensive option for a task with no correctness advantage from extra reasoning power |
Wrong choice: Running this workload on Fable 5 because "better model, better output" sounds intuitively right. At 10,000 calls/day, the difference between Sonnet 5 and Fable 5's blended per-call cost, roughly a 5x multiplier, turns into a five-figure monthly gap for a task where the output quality difference is unlikely to be visible to end users.
Why best is best: Volume is the deciding factor here, not per-call reasoning depth. This is the clearest case in this comparison for treating model choice as a cost-engineering decision, not a quality-maximizing one.
Applying This Comparison
- Classify first by task shape: input-heavy (long documents), output-heavy (long generation), or reasoning-heavy (ambiguous, multi-step). The dominant token category tells you where the price multiplier bites hardest.
- Then classify by genuine difficulty: does the task require weighing trade-offs and catching edge cases, or is it templated/pattern-matching work regardless of length?
- High volume + low difficulty always favors Sonnet 5 (or Haiku 4.5, outside this comparison's scope), the multiplier compounds fastest exactly where it buys the least.
- Low volume + high difficulty tolerates Opus 4.8 or Fable 5, since the absolute dollar cost stays small even at a 5-10x multiplier.
FAQs
Is Fable 5 ever the right default for a whole workload?
Rarely as a blanket default. It's usually reserved for a narrow slice of the highest-stakes, hardest-reasoning calls within a larger pipeline that routes everything else to a cheaper tier.
Does a longer document always mean I need a stronger model?
No, document length drives token count and therefore input cost, not reasoning difficulty. A long but well-structured document can still be handled well by Sonnet 5.
Why does Decision 4's volume argument matter more than Decision 3's?
Cost is volume multiplied by per-call price gap. A large per-call gap on a low-volume task stays a small absolute number, while even a modest gap on a high-volume task compounds into a large one.
Should I always start every new task type on Sonnet 5 and upgrade only if needed?
That's a reasonable default heuristic: start on Sonnet 5, measure failure or rework rate, and escalate specific task classes to Opus or Fable only where the data shows it's warranted.
Where does Haiku 4.5 fit if this page doesn't compare it directly?
Haiku 4.5 sits below Sonnet 5 on both price and typical capability, and is worth evaluating for the simplest, highest-volume task shapes like Decision 1's classification example. See the model tiering article for that comparison.
Does Sonnet 5's price change after 2026-08-31 affect this comparison's rankings?
The absolute numbers shift (roughly $2 to $3 input, $10 to $15 output), but the relative multipliers between Sonnet, Opus, and Fable stay roughly the same, so the rankings in each decision are unlikely to flip.
Is it possible for the cheaper model to actually cost more overall?
Yes, if a cheaper model produces output that requires retries, escalation to a stronger model, or manual rework, the total cost of getting a correct result can exceed what the stronger model would have cost outright.
How much does output-heavy vs input-heavy shape actually change the calculus?
The per-model multiplier (roughly 2.5x for Opus, 5x for Fable, relative to Sonnet) applies equally to input and output, so it changes which token category dominates your bill, but not which model wins a given comparison.
Should every task type get its own cost comparison like this one?
For any task class running at meaningful volume, yes, a quick back-of-envelope pass like the four decisions above is cheap insurance against a model choice that quietly costs 5-10x more than necessary.
Does this comparison account for prompt caching or batching?
No, these are raw synchronous, uncached per-token comparisons. Caching and batching are separate levers covered elsewhere in this section, and they can be layered on top of whichever model tier you land on here.
Related
- How Claude Token Pricing Actually Works - the underlying four-category pricing model behind this comparison.
- Model Tiering: Routing Simple Tasks to Haiku, Hard Tasks to Opus - turning this comparison into an automated router.
- ADR Template: Choosing a Default Model Tier for Your Team - documenting a team-wide default based on this kind of analysis.
- Token Economics Basics - counting tokens to run this comparison against your own real prompts.
Stack versions: Written against the Claude model lineup current as of ~June 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (the default), and Claude Haiku 4.5 - and the official
anthropicPython SDK (latest 0.x release). Model names, pricing, and SDK versions move quickly - verify current specifics at platform.claude.com/docs before relying on them.