Claude Fable 5: Benchmarks, Pricing, API Guide, and How It Differs from Claude Mythos 5

Anthropic released Claude Fable 5 on June 9, 2026 — alongside Claude Mythos 5 — and it marks a meaningful threshold: for the first time, Mythos-class capabilities are publicly available, not restricted to research partners. Fable 5 is Anthropic's most capable generally available model to date, state-of-the-art on nearly every published benchmark, and priced at $10/$50 per million tokens — less than half the cost of Mythos Preview. It also brings a significant architectural change: adaptive thinking is always on, removing the explicit configuration step that Opus 4.8 required.

The headline is the performance gap over Opus 4.8, which was itself a significant jump over Opus 4.7. SWE-Bench Pro goes from 69.2% (Opus 4.8) to 80.3% (Fable 5). That 11-point gap on the benchmark most representative of real agentic coding is the number that will drive adoption decisions. This article covers what you need to know to evaluate and integrate Fable 5: the Fable/Mythos distinction, the full benchmark picture, pricing and caching economics, the safeguard model, and the API integration patterns (Anthropic, 2026a).

Fable 5 and Mythos 5: the same model, different access

Anthropic released two models on June 9. Understanding the distinction matters for enterprise security teams and regulated-industry customers who may qualify for different access levels.

The core insight: Fable 5 and Mythos 5 share the same weights. The difference is entirely in what the safety layer permits. For most engineering teams, Fable 5 is the right choice — the safeguards trigger rarely enough that they are not a practical obstacle for standard software development, data engineering, or analysis workloads. Mythos 5 is relevant specifically for security teams performing offensive research, red-teaming, or infrastructure hardening that requires capabilities the Fable 5 classifiers would otherwise block (Anthropic, 2026a).

Benchmark results

Anthropic describes Fable 5 as state-of-the-art on nearly all tested benchmarks. These are the two benchmarks with independent cross-model comparisons available at launch — the SWE-Bench Pro figure is the most operationally significant, measuring real agentic coding on underspecified tasks rather than clean problem sets (Anthropic, 2026a; Anthropic, 2026b).

Pricing and caching economics

Fable 5 is priced at $10/$50 per million tokens (input/output) — the same as Opus 4.8's Fast Mode, and less than half the cost of Mythos Preview. The Batch API halves this further to $5/$25 per million, matching Opus 4.8's Standard-tier input pricing for asynchronous workloads (Anthropic, 2026b).

The caching multipliers are identical to Opus 4.8 (1.25× for 5-minute writes, 2× for 1-hour writes, 90% saving on reads) — only the base price has increased. In practice, the cache read price of $1.00/M means that a 50,000-token system prompt shared across an agentic session costs $0.50 to write once and $0.05 per read thereafter. For long-running pipelines that inject the same large context repeatedly, the caching economics are the same as on Opus 4.8; only the absolute numbers are higher (Anthropic, 2026b).

The adaptive thinking change

The most significant API-level change from Opus 4.8 is that adaptive thinking is always active on Fable 5. You do not pass a thinking parameter to enable it; you cannot disable it. The model allocates thinking tokens internally based on task complexity — suppressing reasoning for simple lookups, engaging full reflection for multi-step problems — without any configuration overhead.

Raw thinking tokens are never returned in the response. Unlike Opus 4.8 where thinking blocks appeared in response.content and were inspectable (and billable as output), Fable 5 thinking happens entirely server-side. The visible output is the post-reasoning answer only. This means you cannot use thinking blocks as intermediate signals for debugging or cost attribution — a trade-off worth noting for teams that relied on that transparency in Opus 4.8 agents (Anthropic, 2026b).

Safety safeguards and refusal routing

Fable 5 includes safety classifiers that intercept requests in high-risk domains — principally cybersecurity and biological research — before the main model processes them. When a classifier fires, the request is handled by Claude Opus 4.8 instead, which returns a response consistent with Anthropic's standard policy. The classifier triggers in fewer than 5% of sessions on average, and Anthropic acknowledges that the current tuning is conservative — it will occasionally catch legitimate requests (Anthropic, 2026a).

The refusal handling API introduced in Opus 4.8 remains available. When Fable 5 produces a refusal (either from its own judgment or a routed Opus 4.8 response), the response carries stop_reason: "refusal" and a populated stop_details object with category and explanation fields. The routing pattern for security middleware is unchanged from what worked on Opus 4.8.

import anthropic

client = anthropic.Anthropic()

# Fable 5: adaptive thinking always on — no thinking parameter needed
response = client.messages.create(
    model="claude-fable-5",
    max_tokens=8192,
    # effort parameter still controls reasoning budget
    system=[{
        "type": "text",
        "text": system_prompt,
        "cache_control": {"type": "ephemeral", "ttl": "1h"}
    }],
    messages=[{"role": "user", "content": user_message}]
)

if response.stop_reason == "refusal":
    details  = response.stop_details or {}
    category = details.get("category")  # "cyber" | "bio" | None

    # Note: response may have been generated by Opus 4.8 — not Fable 5 — via routing
    # Do not assume Fable 5 context retention for follow-up questions after a refusal
    if category:
        security_log.warning(f"Fable 5 safeguard triggered: {category}", session_id=session_id)
    return handle_refusal(category)

# Normal path: no thinking blocks in response.content
text = next(b.text for b in response.content if b.type == "text")

# Track cost — cache_read_input_tokens reduces effective spend
spend_input  = response.usage.input_tokens        * 10.00 / 1_000_000
spend_cached = response.usage.cache_read_input_tokens * 1.00 / 1_000_000
spend_output = response.usage.output_tokens       * 50.00 / 1_000_000

Plan availability and the June 22 deadline

Platform availability and model IDs

Fable 5 is available across all major cloud platforms from launch day. The model ID conventions follow the same pattern as Opus 4.8 on each provider.

# Anthropic API (direct)
model = "claude-fable-5"

# Amazon Bedrock — InvokeModel (with cross-region prefix for failover)
modelId = "us.anthropic.claude-fable-5"

# Google Cloud Vertex AI
model = "claude-fable-5"

# Microsoft Foundry
model = "claude-fable-5"
# Note: Foundry context window remains 200K tokens (hardware limit)

# GitHub Copilot
# Select "Claude Fable 5" in the model picker across VS Code,
# JetBrains, Xcode, Eclipse, and the GitHub mobile app
# Enterprise admins must enable Fable 5 in Copilot policy settings