Claude Fable 5 vs Sonnet 5 (2026): 5x Pricier, When It Pays

For most teams the answer is "Sonnet 5 as the default, Fable 5 for the hard tail you cannot afford to get wrong." Here is the one-line verdict by scenario.

The rest of this piece is the evidence behind that table, plus the honest version of "when does the $50 tier actually pay."

Two releases three weeks apart reset the top and the middle of the Claude line. Claude Fable 5 shipped on June 9, 2026 as Anthropic's first generally available Mythos-class model — the family Anthropic previously held back over cybersecurity capability. It is the Mythos model with three safety classifiers layered on top. Anthropic put it in Pro, Max, and Team subscription plans for two weeks, then removed it from those plans on June 23, leaving the API rate of $10/$50 as the way in. It has been rotating in and out of access windows since, which matters for how you architect around it.

Claude Sonnet 5 shipped on June 30, 2026 at introductory pricing of $2/$10 (standard $3/$15 after August 31). It is Anthropic's most agentic Sonnet-tier model and the new default for professional work that is not at the frontier.

The reason to compare the two ends directly, rather than each against Opus 4.8, is that they answer different questions. Sonnet 5 answers "what is the cheapest model that clears my everyday bar." Fable 5 answers "what is the best model money can buy when the task is hard enough that being wrong is the expensive outcome." Most teams need both answers, and the interesting decision is where you draw the line between them. This piece is narrower and more practical: two tiers, one routing decision.

Both models share the same nominal 1M context window and 128K max output. The real differences are price, availability, and the fact that Fable 5 cannot turn thinking off.

The intro Sonnet 5 prices ($2/$10) and the cached read ($0.2/M) match Anthropic's published model page as of July 2, 2026. Fable 5's $10/$50 is the Anthropic API rate from Anthropic's Fable 5 announcement; its cached read is the standard 0.1x-of-input ratio Anthropic applies across the line. Fable 5 has been windowed in availability, so confirm it is live on your provider before you build against it. FACTA is vendor-neutral and recommends no specific provider.

On per-token rates the gap is clean: Fable 5 is 5x Sonnet 5 during the introductory window, on input, output, and cached reads alike. After August 31, when Sonnet 5 moves to $3/$15, the multiple drops to about 3.3x. Either way, Sonnet 5 is dramatically cheaper per token.

The sticker understates the real difference for one structural reason. Fable 5's thinking is always on and you cannot turn it off, so on any non-trivial task it produces a chunk of thinking and output tokens that a leaner call would not. Sonnet 5 has adaptive thinking on by default too, but you can dial it down with the effort parameter or disable it outright for bounded work.

Output is the line that bills at $50/M on Fable 5 versus $10/M on Sonnet 5, so more output tokens on the pricier model widens the effective gap beyond the 5x sticker. This is the opposite of the Sonnet-versus-Opus story, where the cheaper model's own thinking narrows the discount. Here the pricier model thinks harder by default, so the gap only grows.

Cached reads are the one place the ratio is a straight 5x with no asterisk. If your prompts carry a large stable prefix (a system prompt, a tool schema, a repeated document set), a cache read is $0.2/M on Sonnet 5 against $1/M on Fable 5. For a cache-heavy production endpoint, that line alone can dominate the monthly bill — and it never favors Fable 5.

Benchmarks are noisy, but the gap between these two is wide enough to survive the noise. Here is where they land on the tests that map to production coding, with Opus 4.8 as the middle-tier reference.

Two rows carry the decision. SWE-bench Pro is the production read. It runs models against real GitHub issues end to end: read the repo, write a patch, the patch either passes the hidden test suite or it does not, no partial credit. Fable 5's 80.3% against Sonnet 5's 63.2% is a 17-point spread, and every one of those points is an issue that closes on the first run instead of failing. On a hard multi-file issue, a first-pass miss means a retry loop or a human picking up the pieces — and both cost more than tokens.

Every's Senior Engineer benchmark is the ceiling read. Every runs it on the hardest problems they can write, the kind a senior engineer takes a working day to solve. Fable 5 at 91/100 lands in human-senior-engineer range; Opus 4.8 sits at 63. Anthropic has not published a Sonnet 5 figure for this test, but Sonnet 5 already trails Opus 4.8 on SWE-bench Pro (63.2% vs 69.2%), so on a harder benchmark it lands at or below Opus, not near Fable 5. That is the gap the price premium buys: not "a bit better on average," but "can do a class of task the cheaper model mostly fails."

Treat these leaderboard scores as a snapshot and check Anthropic's Transparency Hub for the per-benchmark source; the direction is what matters for routing, not the last decimal. The honest summary: for everyday coding, the extra points do not change the outcome, because Sonnet 5 already closes the issue. For frontier coding, the extra points are the difference between shipping and stalling.

Sticker price is one number, cost-per-solved-issue is another, and they can point in different directions. Here are two workloads with the assumptions stated so you can swap in your own.

Scenario A — an everyday coding fleet

5 developers, 20 tasks/day each, 20 workdays (2,000 tasks/month). Per routine task: 40K input, and output of 8K on Sonnet 5 (thinking dialed low) versus 25K on Fable 5 (thinking always on). Assume the task is well within both models' reach, so first-pass success is near 1 on both.

On routine work Fable 5 is not 5x more expensive — it is roughly 10x, because the always-on thinking piles onto the $50 output line. Paying that for work Sonnet 5 already closes is pure waste.

Scenario B — the hard tail

Now take genuinely hard, multi-file issues where first-pass success is the whole game. Use the SWE-bench Pro rates as a stand-in: 80.3% for Fable 5, 63.2% for Sonnet 5. Per attempt: 60K input, 40K output on Fable 5, 30K output on Sonnet 5.

On tokens alone, Sonnet 5 is still cheaper per solved issue even after retries, because a fifth of the per-attempt price buys a lot of retries. So the case for Fable 5 is not a token-cost case. It is this: the SWE-bench Pro rate flatters Sonnet 5 on the hardest tasks. On the class of problem Every's benchmark targets (where Fable 5 scores 91 and Opus 4.8 only 63), Sonnet 5's real-world solve rate falls well below its 63.2% headline, its retry count climbs, and some issues it never closes.

Once a failed patch costs an hour of senior engineer time or ships a bug, the $3 token delta stops being the number that matters. That is when Fable 5 pays: not because it is cheaper, but because being wrong is expensive and it is wrong less often.

Pick anthropic/claude-sonnet-5 for the large majority of work.

Pick anthropic/claude-fable-5 when the task is at the capability frontier and a wrong answer is the expensive outcome.

Two cases fall between the tiers. The first is cybersecurity, biology and chemistry, or model distillation work. Fable 5 detects these and routes them to Opus 4.8 anyway, so calling Fable 5 for them just adds a routing hop. Call anthropic/claude-opus-4.8 directly and skip it.

The second is the middle of the difficulty range — the tasks that are too hard for Sonnet 5 to close reliably but not hard enough to justify Fable 5's 10x effective cost. That is exactly where Opus 4.8 lives: $5/$25, 69.2% SWE-bench Pro, and no availability window to plan around. For a lot of teams the real routing tree has three tiers, not two, with Opus 4.8 as the everyday-hard workhorse and Fable 5 reserved for the genuine frontier.

The routing decision, end to end:

The honest way to settle the routing line is to run both on your own tasks and read the token counts. An OpenAI-compatible gateway exposes the Claude line on one endpoint, so the only thing that changes between runs is the model ID string, and one key covers all three tiers with no separate Anthropic billing.

Two gotchas before you run it: both models reject non-default temperature, top_p, and top_k with a 400, so leave sampling params alone (the examples do). And Fable 5 must be live in an access window for its line to resolve; when it is not listed, either wait for the window or point that one call at Anthropic's own API.

Python: A/B both models in one loop

from openai import OpenAI

client = OpenAI(base_url="https://your-gateway.example/v1", api_key="YOUR_GATEWAY_KEY")

prompt = "Fix the race condition in this worker pool: ..."
for model in ["anthropic/claude-fable-5", "anthropic/claude-sonnet-5"]:
    r = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    u = r.usage
    print(model, u.prompt_tokens, u.completion_tokens)

Watch the completion_tokens column. Fable 5's always-on thinking shows up there, and multiplied by $50/M it is where the effective cost gap lives.

Node: same shape

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://your-gateway.example/v1", apiKey: process.env.GATEWAY_KEY });

const prompt = "Fix the race condition in this worker pool: ...";
for (const model of ["anthropic/claude-fable-5", "anthropic/claude-sonnet-5"]) {
  const r = await client.chat.completions.create({
    model,
    messages: [{ role: "user", content: prompt }],
  });
  console.log(model, r.usage.prompt_tokens, r.usage.completion_tokens);
}

Run this on 20 or 30 of your genuinely hard tasks, sum input and output tokens per model, multiply by the specs-table rates, and divide by how many each model actually solved. That solved-issue cost, not the sticker, is the number that decides where the routing line goes.

Both models keep the Messages API shape, but the same request that worked on an older Claude can 400 on either of these.

The Fable 5 rows are the ones that trip people. Thinking is always on, so there is no disable switch, and the safety classifiers can hand a request to Opus 4.8 mid-flight. On the API, opt into a fallback so a refusal does not just stop the request; Anthropic's server-side fallbacks parameter re-serves a declined request on Opus 4.8 in the same call.

If you are moving a Sonnet 5 workload up to Fable 5 for the hard tail, budget for more output tokens per task, not fewer, because the always-on thinking works against the intuition that a smarter model finishes faster. The routing test is not the benchmark score — it is cost-per-solved-issue: run both on your real hard tasks, count the tokens, and count how many each one actually closed.

• An OpenAI-compatible gateway puts Sonnet 5, Opus 4.8, and Fable 5 (when in-window) on one endpoint, so routing between tiers is a one-string change rather than three integrations. Real-time pricing is on your provider's model catalog.
• Opus 4.8 is the middle tier worth naming explicitly: $5/$25, 69.2% SWE-bench Pro, always available, no window to plan around. For the tasks between Sonnet 5's ceiling and Fable 5's floor, it is often the right pick.
• Anthropic direct is the fallback for Fable 5 specifically. When Fable 5 is not listed on an aggregator, its own API keeps the $10/$50 rate available, at the cost of a second key and separate billing.

The interesting decision in a two-tier lineup is never which model is better. It is where you draw the line — and that line is a cost-per-solved-issue line, not a sticker-price line.

Sticker price punishes the obvious mistake: paying 5x for work the cheap model already closes. But cost-per-solved-issue punishes the subtler one: sending a hard task to the cheap model and paying for it in retries, human cleanup, and shipped bugs. The two numbers point in different directions exactly on the tasks that matter most.

The trap is letting the cheap default leak up into the hard tail, or letting the ceiling model leak down into the routine 80%. Both are waste, but only the second one shows up on the invoice and feels like you overpaid for AI — which is why teams overcorrect and run everything on the cheap tier, then wonder why their hard issues stall.

The discipline is to measure the share, keep the ceiling tier small, and let a saved engineer-hour — not a saved token — be the thing that justifies the 10x line.

The routing line that pays is cost-per-solved-issue, not sticker price — and the model that's wrong less often is worth 10x only on the tasks where being wrong is the expensive outcome.

• Anthropic, "Claude Fable 5 and Mythos 5" announcement (Fable 5 $10/$50, Mythos-class, safety classifiers routing to Opus 4.8), verified July 2, 2026
• Anthropic, "Introducing Claude Fable 5" docs (always-on thinking, no sampling params, refusal handling)
• Anthropic, "Introducing Claude Sonnet 5" launch post, June 30, 2026
• Anthropic, "What's new in Claude Sonnet 5" docs (behavior changes, pricing)
• Anthropic Transparency Hub (per-benchmark source)
• SWE-bench Pro / SWE-bench Verified / Every Senior Engineer figures from Anthropic launch materials and Every's published benchmark

About FACTA

FACTA is an AI consulting firm. We help teams pick the right model for the right task, route between tiers, and measure cost-per-outcome instead of cost-per-token.

We write these comparisons because the sticker price is the number vendors quote and the cost-per-solved-issue is the number that actually decides routing. A two-tier lineup is a chance to get that line right instead of defaulting to one model for everything.

If you are designing a tiered model-routing setup — or want a vendor-neutral evaluation of which Claude model fits which slice of your workload — we can help.

Vendor-neutral by design. Cost-per-outcome by habit.