Claude Fable 5: The First Mythos-Class Model You Can Actually Call

Every so often a model release shifts the ceiling rather than nudging it, and Claude Fable 5 is one of those. Announced by Anthropic on 9 June 2026, Fable 5 is the first Mythos-class model made generally available — a new tier that Anthropic positions above the Opus class in raw capability (Anthropic, “Claude Fable 5 and Claude Mythos 5”).

If you have been building on Opus or Sonnet, most of your code will keep working. But Fable introduces one genuinely new behaviour — it can decline a request and hand it to a different model — and if you do not plan for that, your integration will do something surprising in production. So this post does two things: it explains what actually makes Fable different, and it gives you a working Python example that handles the new behaviour without falling over.

Think of it like hiring a brilliant but heavily vetted new colleague. They are the sharpest person in the building, but on certain sensitive topics they are contractually obliged to pass the ticket to someone else. Useful to know before you route all your traffic to them.

Availability Note (July 2026)

A quick reality check before you get too attached: Fable 5’s rollout has been anything but smooth. Access was suspended on 12 June 2026 after the US government briefly applied export controls, then restored on 1 July once those controls were lifted (MacRumors). So if the model is showing as not available when you try it, that is frustratingly on-brand for this launch. Before assuming a fault at your end, check three things:

• Your plan’s usage credits. Free Fable 5 access on Pro, Max, Team, and seat-based Enterprise plans was extended to 12 July 2026. After that it no longer counts toward your plan’s included usage, and continued access needs a funded, prepaid usage-credit balance.
• Capacity. Anthropic warned that demand would be high and hard to predict, and has rolled subscription access out conservatively — so transient unavailability is expected rather than exceptional.
• The status page. For live incidents, the Anthropic status page is the fastest source of truth.

In short: an “unavailable” message is far more likely to be a rollout or billing gate than a bug in your code. The refusal-and-fallback pattern below is your friend here too — routing to Opus 4.8 keeps your application working even when Fable itself is out of reach.

What “Mythos-Class” Means, and Why Fable and Mythos Are Twins

Anthropic describes Mythos-class as a tier of models sitting above the Opus class in capability. Fable 5 and Mythos 5 share the same underlying model — same weights, same specs, same pricing. The only thing that separates them is safety (Claude Platform Docs, “Introducing Claude Fable 5 and Claude Mythos 5”).

Mythos 5 ships with certain safeguards lifted, and it is not something you can simply sign up for — it is offered in limited availability to approved partners through Project Glasswing, largely for cyberdefence and critical-infrastructure work. Fable 5, by contrast, is the version the rest of us get: the same capability, wrapped in safety classifiers so it can be released to everyone. Anthropic even notes the naming: fable comes from the Latin fabula, “that which is told,” a cousin of the Greek mythos. The safeguards are the whole difference between the two names.

For the vast majority of us who will never touch Mythos 5, the practical takeaway is reassuring: on the ~95% of sessions that never trigger a classifier, Fable 5’s performance is effectively identical to Mythos 5’s.

How Fable 5 Differs From Opus 4.8 and Sonnet 5

Three things stand out when you move from an Opus- or Sonnet-based integration to Fable 5.

First, it is more capable on long, complex work. Anthropic states Fable is state-of-the-art on nearly all tested capability benchmarks, and — crucially — that the longer and more complex the task, the larger its lead over their other models. Early customers put numbers on this: Stripe reported Fable compressed a codebase-wide migration of a 50-million-line Ruby codebase into a single day, work that would otherwise have taken a team over two months (Anthropic news post).

Second, adaptive thinking is always on. On Fable 5 and Mythos 5, adaptive thinking is the only thinking mode. You cannot disable it (thinking: {"type": "disabled"} is unsupported); instead you control depth with the effort parameter. The raw chain of thought is never returned — you get either a summarised version or an empty thinking block, controlled by thinking.display (Claude Platform Docs).

Third, and most importantly for your code, Fable 5 can refuse. Its safety classifiers cover cybersecurity, biology and chemistry, and model distillation. When one triggers, the request is handled by Claude Opus 4.8 instead of Fable, and the user is told. This is the one behaviour that has no equivalent on Opus or Sonnet, so we will spend real time on it below.

Features and Capabilities at a Glance

Fable 5 and Mythos 5 share the same technical specification (Claude Platform Docs):

• Context window: 1M tokens by default, billed at standard rates across the whole window — a 900k-token request costs the same per token as a 9k-token one (Pricing docs, long context).
• Output: up to 128k output tokens per request.
• Thinking: always-on adaptive thinking, tuned with the effort parameter.
• Vision: the new state-of-the-art for vision tasks — extracting numbers from scientific figures, or rebuilding a web app’s source from screenshots alone.
• Agentic tooling at launch: the memory tool, code execution, programmatic tool calling, context editing, compaction, and task budgets.
• Model IDs: claude-fable-5 and claude-mythos-5.
• Availability: Fable 5 is generally available on the Claude API, Claude Platform on AWS, Amazon Bedrock, Google Cloud, and Microsoft Foundry.

One quiet gotcha worth flagging: Fable 5 (like Opus 4.7 onwards and Sonnet 5) uses a newer tokeniser that produces roughly 30% more tokens for the same text than Sonnet 4.6 and earlier (Pricing docs). Your token counts — and therefore your bill — will not map one-to-one from an older model. Budget accordingly.

Token Input and Output Costs

Fable 5 and Mythos 5 are priced identically, at $10 per million input tokens and $50 per million output tokens — described by Anthropic as less than half the price of Claude Mythos Preview (Anthropic news post). For context, here is how that lands against the models you are probably migrating from (Pricing docs):

The pattern is clear: Fable is roughly twice the price of Opus 4.8 and five times Sonnet 5. That premium is easy to justify for hard, long-horizon problems and easy to waste on routine work. Two levers keep the bill sane. The Batch API halves both input and output for non-time-sensitive jobs (down to $5/$25). And because you are billed nothing for a request that is refused before any output is generated, the fallback-credit mechanism refunds the prompt-cache cost of switching so you do not pay it twice.

Handling Refusals and Fallback in Python

Here is the part that will actually break if you ignore it. When Fable 5 declines a request, the Messages API does not return an error. It returns a perfectly successful HTTP 200 with stop_reason: "refusal" (Refusals and fallback docs). If your code only checks for exceptions, it will sail straight past this and hand your user an empty response.

The example below calls Fable 5, detects a refusal, and falls back to Opus 4.8 — the same model Anthropic’s own server-side fallback uses. It runs against the official anthropic SDK and needs only an API key in your environment.

"""
Call Claude Fable 5 and gracefully fall back to Opus 4.8 on a refusal.

Fable 5 returns stop_reason == "refusal" as a successful HTTP 200 response
rather than raising an error, so we must inspect the response, not just
catch exceptions.

Requires:  pip install "anthropic>=0.40"
Env var:   ANTHROPIC_API_KEY
"""

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

PRIMARY_MODEL = "claude-fable-5"
FALLBACK_MODEL = "claude-opus-4-8"

# Published rates in USD per million tokens (July 2026).
PRICING = {
    "claude-fable-5": {"input": 10.0, "output": 50.0},
    "claude-opus-4-8": {"input": 5.0, "output": 25.0},
}


def estimate_cost(model: str, usage) -> float:
    """Return the approximate USD cost of a single response."""
    rates = PRICING[model]
    return (
        usage.input_tokens / 1_000_000 * rates["input"]
        + usage.output_tokens / 1_000_000 * rates["output"]
    )


def ask(prompt: str, max_tokens: int = 1024) -> dict:
    """Ask Fable 5, falling back to Opus 4.8 if Fable refuses."""
    response = client.messages.create(
        model=PRIMARY_MODEL,
        max_tokens=max_tokens,
        messages=[{"role": "user", "content": prompt}],
    )

    # A refusal is a *successful* response with stop_reason == "refusal".
    if response.stop_reason == "refusal":
        print(f"[fallback] {PRIMARY_MODEL} declined; retrying on {FALLBACK_MODEL}.")
        response = client.messages.create(
            model=FALLBACK_MODEL,
            max_tokens=max_tokens,
            messages=[{"role": "user", "content": prompt}],
        )
        served_by = FALLBACK_MODEL
    else:
        served_by = PRIMARY_MODEL

    text = "".join(
        block.text for block in response.content if block.type == "text"
    )
    return {
        "served_by": served_by,
        "text": text,
        "cost_usd": estimate_cost(served_by, response.usage),
    }


if __name__ == "__main__":
    result = ask("Explain the trade-off between latency and throughput "
                 "in a request queue, in three sentences.")
    print(f"Served by : {result['served_by']}")
    print(f"Cost (USD): {result['cost_usd']:.6f}")
    print(f"Answer    :\n{result['text']}")

Two things to note. The refusal check is the load-bearing line — everything else is ordinary SDK usage. And the cost estimator quietly bills the fallback model’s rate when a fallback happens, because that is what you actually pay. In production you would lean on Anthropic’s built-in options rather than rolling your own: the server-side fallbacks parameter (in beta), or the SDK middleware for client-side retries. But hand-rolling it once, as above, is the fastest way to understand what those conveniences are doing on your behalf.

Where Fable 5 Earns Its Keep

Given the price premium, Fable 5 is not the model you reach for to summarise a paragraph — that is what Haiku and Sonnet are for. It pays off on work that is long, complex, and where a better answer is worth real money:

• Large-scale code migration and modernisation. The Stripe example — a two-month, 50-million-line migration done in a day — is the archetype. This is code modernisation territory, where Fable’s lead grows with task length.
• Long-horizon agentic work. With a 1M-token window, the memory tool, and compaction, Fable stays coherent across millions of tokens and improves its own output from its notes. Anthropic’s playful proof was having it complete Pokémon FireRed from raw screenshots alone, and reach the final act of Slay the Spire far more often when given file-based memory.
• Knowledge work and analysis. Fable posted the highest score any model has managed on Hebbia’s senior-level finance benchmark, with strong gains in document reasoning and chart and table interpretation — the sort of thing that matters in financial services and legal review.
• Vision-heavy tasks. Reconstructing code from screenshots, or reading precise values off scientific figures, where it is now state-of-the-art.
• Scientific research (via Mythos 5 for approved partners). Anthropic reports around a 10x acceleration in parts of the protein-design process and its first model to consistently produce novel, testable molecular-biology hypotheses.

A sensible pattern for most teams: route the bulk of traffic to Sonnet or Opus, and escalate to Fable 5 only for the genuinely hard tickets — the ones a customer “hits a wall” on. That keeps the premium where it earns its keep.

Conclusion

Claude Fable 5 is the most capable model Anthropic has put in front of the general public, and for long, complex, agentic work the gap over Opus and Sonnet is real. The trade-offs are equally real: you pay roughly double Opus 4.8, a newer tokeniser inflates your token counts by around 30%, and — the one thing you must not skip — Fable can refuse a request and quietly hand it to Opus 4.8 via a successful stop_reason: "refusal" response. Handle that one case, lean on the effort and Batch levers to control cost, and reserve Fable for the tickets that deserve it. Do that, and you get frontier capability without an ugly surprise on either your bill or your error logs.

If you would like a follow-up post benchmarking Fable 5 against Opus 4.8 on a real migration task, let me know in the comments — I am tempted to run exactly that experiment.

References

• Anthropic, “Claude Fable 5 and Claude Mythos 5” (9 June 2026)
• Claude Platform Docs, “Introducing Claude Fable 5 and Claude Mythos 5”
• Claude Platform Docs, “Pricing”
• Claude Platform Docs, “Refusals and fallback”
• Claude Platform Docs, “Adaptive thinking” and “Effort”
• Anthropic, “Project Glasswing”