Claude Fable 5.2: when a flagship model is worth paying for

Fable 5.2 costs 80 times what Haiku 5.5 does per token. A practical guide to model tiers, effort settings, and an escalation pattern that sends each task to the cheapest model that passes.

Last checked:

Sections

Anthropic released Claude Fable 5.2 on Monday. It's the top of the Claude range, and a launch like this always brings out the same two opinions: use it for everything, or it's overpriced and Sonnet is fine.

Both miss the useful question. There are now four current Claude models with an 80-fold price spread between the smallest and the largest, and each has an effort setting that changes what a task costs. Picking one model for everything means overpaying for easy work or underpowering hard work. Usually both, in the same application.

This post is about choosing per task: what Fable 5.2 is, where a flagship earns its price, where it's wasted, and a small escalation pattern that makes the choice automatically. The benchmark figures are Anthropic's. The cost examples use made-up workloads to show the math.

What shipped

From Anthropic's announcement:

One sentence in the announcement is easy to skip: Anthropic still recommends starting with Opus 5.5 for most coding and knowledge work. The company that sells the flagship is telling you it isn't the default. I'd take that at face value.

The four tiers

Here's the current range, from Anthropic's models overview. Prices are per million tokens, input then output.

All four have a 1M-token context window, so "it can read more" is no longer a reason to move up.

Anthropic's list prices / November 2026 An 80-fold spread from bottom to top. Output price per million tokens. Input prices follow the same ratios.
  • Haiku 5.5from $0.10 in
    $0.50 · 1×
  • Sonnet 5.5$2 in
    $10 · 20×
  • Opus 5.5$4 in
    $20 · 40×
  • Fable 5.2$8 in
    $40 · 80×
FIG. 01 From Anthropic's models overview. Fable's optional fast mode doubles its price to $16 and $80. Haiku bills prompts over 100,000 tokens at a higher rate, not shown here.

The ratios are what matter. Fable costs twice what Opus does, four times Sonnet, and 80 times Haiku. A task that's fine on Haiku and runs on Fable is burning 79 of every 80 dollars.

Price per token is not price per task

The rate card is only half the calculation. The other half is how many tokens the model uses to finish, and that depends on the effort setting.

Each of these models has effort levels from Low to Max. Lower effort means less reasoning, fewer tokens, and a faster answer. Higher effort means the model thinks longer and checks its work.

That creates a result that surprises people. Anthropic reports two examples in the launch post:

So the more expensive model, turned down, was cheaper than the less expensive model turned all the way up. A stronger model can reach the answer in fewer steps, and steps are what you pay for.

Those are the vendor's benchmarks, and your tasks are not benchmarks. The lesson that carries over is the method: when you compare models, compare model and effort setting together, and measure the cost of a finished, correct task. "Sonnet at Max" and "Fable at Low" are both candidates for the same job.

Where a flagship earns its price

The top tier pays for itself in a few specific situations.

Long tasks with many dependent steps. A migration across a large codebase, a multi-day research task, an agent that has to keep a plan straight for hours. Small errors compound over a long run, and a model that makes fewer of them finishes more often.

Ambiguous problems. When the hard part is working out what the question is: a vague spec, conflicting requirements, a bug nobody can reproduce.

Work where a mistake is expensive. A contract analysis someone will act on, a financial model, an architectural decision. If a wrong answer costs a day of someone's time, an extra dollar on the model is easy to justify.

Planning and review around cheaper models. A flagship can write the plan that smaller models carry out, or review their output at the end. It touches a small share of the tokens and shapes the whole result.

The last few cases. The 3% of inputs that every cheaper model gets wrong.

Even here, some humility is in order. Anthropic's own table includes the Remote Labor Index, a benchmark built from real freelance projects, where Fable 5.2 completes about 41% and Opus 5.5 about 21%. That's a large jump, and it also means the best model available still fails most of them. A flagship raises the odds. It doesn't remove the need to check.

Where it's wasted

Classification and routing. Which queue, which category, is this spam. Haiku handles these, and so do the decision models that cost even less.

Extraction from clean documents. Pulling a date, a total, and a vendor name from an invoice.

Short drafts with a clear brief. A reply to a routine customer email.

Anything you run thousands of times without looking. Volume multiplies the price difference, and the task is usually simple enough not to need the top tier.

Tasks that failed for a non-model reason. If the model didn't have the right document or the instructions were unclear, a bigger model gives you a more eloquent wrong answer. Fix the input first.

I wrote about the same idea in using small models to break down problems: narrow tasks go to small models, and application code owns the structure.

Escalate only when a check fails

The pattern is simple. Try the cheapest tier. Check the result with code. If the check fails, try the next tier up. Record what happened.

from dataclasses import dataclass
from typing import Callable

PRICES = {  # USD per million tokens: (input, output)
    "claude-haiku-5-5": (0.10, 0.50),
    "claude-sonnet-5-5": (2.00, 10.00),
    "claude-fable-5-2": (8.00, 40.00),
}


@dataclass
class Attempt:
    model: str
    output: str
    input_tokens: int
    output_tokens: int
    passed: bool

    @property
    def cost(self) -> float:
        price_in, price_out = PRICES[self.model]
        return (self.input_tokens * price_in + self.output_tokens * price_out) / 1_000_000


def run_with_escalation(
    task: str,
    call_model: Callable[[str, str], tuple[str, int, int]],
    check: Callable[[str], bool],
    tiers: tuple[str, ...] = tuple(PRICES),
) -> list[Attempt]:
    attempts: list[Attempt] = []
    for model in tiers:
        output, tokens_in, tokens_out = call_model(model, task)
        attempt = Attempt(model, output, tokens_in, tokens_out, check(output))
        attempts.append(attempt)
        if attempt.passed:
            break
    return attempts

call_model is your API call, returning the text and the token counts from the provider's usage data. check is where the real work is. The list of attempts is your record: which tier answered, what it cost, and whether anything passed at all. If the last attempt didn't pass, the task goes to a person.

A few notes on making this work:

The prices in that table will change. Keep them in configuration and read the current pricing page when you set it up. Haiku's higher rate for long prompts isn't modeled here.

The math on a thousand documents

Say you process 1,000 documents, and each takes about 6,000 input tokens and 800 output tokens. Per document, that's roughly:

Send everything to Fable and the batch costs about $80. Now use escalation, and suppose 85% pass on Haiku, 12% need Sonnet, and 3% need Fable:

About $6.40, with the hardest 3% still getting the best model. Those pass rates are invented. Yours come from running the pattern on real documents.

The pattern / 1,000 documents, invented pass rates Move up a tier only when a check fails. Every document starts on Haiku. Code checks each result. Failures carry what went wrong to the next tier.
  1. TIER 1Haiku 5.51,000 attempts850 pass the check · $1.00
  2. TIER 2Sonnet 5.5150 attempts120 pass the check · $3.00
  3. TIER 3Fable 5.230 attemptsThe hardest 3% · $2.40
  4. LASTA personAnything nothing passedThe list you want regardless of price
  • Everything on Fable
    about $80
  • With escalation
    about $6.40
FIG. 02 About 6,000 input and 800 output tokens per document, at list prices. The 85 / 12 / 3 split is made up to show the math. Yours comes from running the pattern on real documents.

At a thousand documents, the difference is $74, and nobody's business turns on that. Two things make it matter. The first is volume: at a million documents it's $74,000. The second is that the pattern gives you a check on every result and a list of the ones nothing could handle, which you want regardless of price.

Test before you assume

Whether you need the top tier is an empirical question, and it's cheap to answer.

Take your saved cases, the ones I described in a faster model at the same price, and run them across tiers and effort levels. You're looking for the cheapest combination that passes everything that matters.

Three things to look for in the results:

Run it again when a new model ships. A task that needed the flagship in June may pass on the mid-tier in November.

Fast mode, and other practical details

Fast mode. Double the price for up to 2.5 times the generation speed. It's worth it when a person is waiting on the answer, such as an interactive coding session. It's wasted on a batch job that runs overnight.

Safeguards. Anthropic says Fable 5.2's safeguards block high-risk cybersecurity work such as penetration testing and exploit generation, along with most research biology, and that blocked requests are answered by an older model. If your work is near security, such as log analysis or vulnerability triage, test those requests before you depend on it. You may get a different model's answer without expecting to.

Data retention. For most API customers, Fable 5.2 has 30-day retention for safety monitoring. Zero data retention is available to eligible customers. If you chose a model partly for its retention terms, check them again for this one.

Subscription limits. On Claude's paid plans, Fable use counts against weekly limits, and the launch post describes how much is included by plan. If you hit limits partway through the week, the per-task choice applies in the app too.

If you just use the app

You don't need any of this machinery to choose well in a chat app.

Use the default model for everyday work: drafting, summarizing, quick questions. Switch to the flagship for the task you'd otherwise set aside half a day for: a difficult document to analyze, a plan with a lot of moving parts, a problem you've already failed to solve with the regular model. If the answer wasn't good enough the first time and the instructions were clear, that's the signal to move up.

Pay for the hard parts

The useful change with Fable 5.2 isn't that there's a better model at the top. There's always a better model at the top. It's that four tiers and an effort dial give you real control over what each task costs, if your application is built to use it.

Send work to the cheapest tier that passes, check every result, and save the flagship for what's left.

Designing that kind of pipeline, with the checks and the saved cases that make it trustworthy, is part of the custom software and AI consulting work I do. If your AI bill or your error rate is higher than it should be, tell me what you're running.

Related: LangSmith and the rest of the eval stack for building the test cases, and prompt caching in production for the other big cost lever.

More notes

All notes · Contact