Anthropic Unveils Claude Fable 5.1 & Mythos 5.1: Science Benchmarks Double, Cache Costs Drop 75%, AI Begins Doing Science Firsthand

Anthropic Unveils Claude Fable 5.1 & Mythos 5.1: Science Benchmarks Double, Cache Costs Drop 75%, AI Begins Doing Science Firsthand

1. TL;DR

On September 1, 2026, Anthropic officially released Claude Fable 5.1 and Claude Mythos 5.1. The two models share identical underlying weights, differentiated only by the tightness of their safety guardrails. Fable 5.1 is generally available to the public, while Mythos 5.1 is restricted to vetted cybersecurity and life sciences organizations through the Project Glasswing trusted access program.

Key Highlights at a Glance:

Source: Anthropic official announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1)

2. Model Architecture: One Model, Two Guardrails

2.1 Shared Weights, Divergent Policies

Fable 5.1 and Mythos 5.1 share the exact same underlying weights. Anthropic employs a “one training, multi-level deployment” strategy—at inference time, guardrails dynamically route behavior.

+--------------------------------------------------+
|            Shared Model Weights                    |
+--------------------------------------------------+
          |                        |
          v                        v
+------------------+    +---------------------+
|  Fable 5.1       |    |  Mythos 5.1         |
|  Public Guardrails|    |  Restricted Access  |
|  - Cyber: Medium  |    |  - Cyber: Light     |
|  - Bio: Medium    |    |  - Bio: Light       |
|  - Vuln Discovery |    |  - Exploit Dev: OK  |
|  - Exploit: Block |    |  - Pentest: OK      |
+------------------+    +---------------------+
          |                        |
          v                        v
+------------------+    +---------------------+
| Public Launch    |    | Project Glasswing   |
| API / AWS / GCP  |    | Invite-only Orgs     |
| Azure / Claude   |    | US-based primarily  |
+------------------+    +---------------------+

2.2 Platform Availability

Source: Anthropic official announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1)

3. Benchmark Deep Dive

3.1 Terminal-Bench-Science 0.1: From Incremental to Transformational

Terminal-Bench-Science 0.1, a new benchmark first published on August 27, 2026, was built by a Stanford-led consortium with advisors from MIT, Princeton, University of Washington, Genentech, and Stanford. It contains 70 tasks contributed by real scientists spanning life sciences, physics, earth sciences, mathematics, and engineering. The model operates in an isolated terminal environment, performing data analysis, statistical inference, simulation construction, and theorem proving—scored by hidden tests with no partial credit.

Science Benchmark Comparison (Terminal-Bench-Science 0.1)
Score: 52.6%
  |
  |███████████████████████████████████████████████████████████  Fable 5.1
  |
  |████████████████████████████████        29.0%  Opus 5
  |
  |██████████████████████████              24.7%  Fable 5
  |
  |██████████████████████                  22.4%  GPT-5.6 Sol
  |
  +---------------------------------------------------->
   0%       10%       20%       30%       40%       50%       60%

Fable 5.1’s 52.6% versus Fable 5’s 24.7% represents a doubling of performance. What drives this?

The answer is systematic improvement in long-chain reasoning capability. Scientific tasks aren’t single-turn Q&A—they require the model to read data → formulate hypotheses → design experiments → run analysis → interpret results → adjust approaches → re-execute. A break at any point means the entire task is lost.

3.2 Complete Benchmark Matrix

Source: Anthropic System Card (https://www.anthropic.com/claude-fable-and-mythos-5-1)

3.3 Key Finding: Structural Breakthrough in Agentic Capability

Fable 5.1’s most dramatic improvement is on AutomationBench—from 17.1% to 31.4%, nearly doubling. This benchmark measures end-to-end business workflow automation, representing multi-step “do this entire process” tasks.

Agentic Capability Improvement
         Fable 5    Fable 5.1    Improvement
            |           |
Science     |██████████|███████████████████████████████  +113%
            |           |
Automation  |██████████|███████████████████████████████  +84%
            |           |
Terminal    |██████████|███████████████████████████████  +33%
            |           |
CursorBench |██████████|███████████████████████████████  +4%
            +-----------+----------------------------------->
            0%          20%          40%          60%          80%

Interpretation: The longer and more multi-step the task, the larger Fable 5.1’s improvement. This isn’t uniform “smarter”—it’s a targeted raising of the long-chain reasoning ceiling.

4. Pricing Strategy & Cost Optimization Deep Dive

4.1 Complete Pricing Table

Fable 5.1’s base input/output prices remain unchanged from Fable 5. The only price reduction is on cache reads.

Source: Anthropic pricing page (https://www.anthropic.com/claude-fable-and-mythos-5-1)

4.2 Why Cache Reads Are the Star of This Release

20-Turn Agent Loop Cost Comparison (250K token static context)

Fable 5 (No Cache):
  Input: 250K × 20 turns = 5M tokens × $10/M = $50.00
  Output: 2K × 20 turns = 40K tokens × $50/M = $2.00
  Total: $52.00

Fable 5.1 (Cache Read @ $0.25/M):
  Turn 1 (Cache Write): 250K × $12.50/M = $3.125
  Turns 2-20 (Cache Reads): 250K × 19 turns = 4.75M × $0.25/M = $1.188
  Output: 40K × $50/M = $2.00
  Total: $6.313

Savings: 87.8%!

Source: Third-party technical analysis (https://teachaitools.blog/blog/claude-fable-51-mythos-51-prompt-cache-cost-cut-2026)

4.3 The Math Behind the Savings

package main

import (
	"fmt"
)

type CostBreakdown struct {
	Cost      float64
	Breakdown map[string]float64
}

type SavingsResult struct {
	F5Total    float64
	F51Total   float64
	SavingsPct float64
	F5Detail   map[string]float64
	F51Detail  map[string]float64
}

func calculateSavings(cachedTokens, uncachedTokens, outputTokens int, turns int) SavingsResult {
	// Fable 5 pricing
	const (
		F5_INPUT  = 10.0  // $/M tokens
		F5_CACHE  = 1.0   // $/M tokens
		F5_OUTPUT = 50.0  // $/M tokens
	)

	// Fable 5.1 pricing
	const (
		F51_CACHE_WRITE = 12.50 // $/M tokens
		F51_CACHE_READ  = 0.25  // $/M tokens
		F51_OUTPUT      = 50.0  // $/M tokens
	)

	// Fable 5: every turn billed at input rate
	f5Input := float64((cachedTokens+uncachedTokens)*turns) * F5_INPUT / 1_000_000
	f5Output := float64(outputTokens*turns) * F5_OUTPUT / 1_000_000
	f5Total := f5Input + f5Output

	// Fable 5.1: first turn writes cache, subsequent turns read
	writeCost := float64(cachedTokens) * F51_CACHE_WRITE / 1_000_000
	readCost := float64(cachedTokens*(turns-1)) * F51_CACHE_READ / 1_000_000
	inputCost := float64(uncachedTokens*turns) * F5_INPUT / 1_000_000
	outputCost := float64(outputTokens*turns) * F51_OUTPUT / 1_000_000
	f51Total := writeCost + readCost + inputCost + outputCost

	savingsPct := (f5Total - f51Total) / f5Total * 100

	return SavingsResult{
		F5Total:    f5Total,
		F51Total:   f51Total,
		SavingsPct: savingsPct,
		F5Detail: map[string]float64{
			"input":  f5Input,
			"output": f5Output,
		},
		F51Detail: map[string]float64{
			"cache_write":    writeCost,
			"cache_read":     readCost,
			"uncached_input": inputCost,
			"output":         outputCost,
		},
	}
}

func main() {
	// Typical agent scenario: 250K cached context, 20-turn interaction
	result := calculateSavings(250_000, 1_000, 2_000, 20)
	fmt.Printf("Fable 5 cost:    $%.2f\n", result.F5Total)
	fmt.Printf("Fable 5.1 cost:  $%.2f\n", result.F51Total)
	fmt.Printf("Savings:         %.2f%%\n", result.SavingsPct)
	fmt.Printf("\nFable 5 breakdown:\n")
	fmt.Printf("  Input:  $%.2f\n", result.F5Detail["input"])
	fmt.Printf("  Output: $%.2f\n", result.F5Detail["output"])
	fmt.Printf("\nFable 5.1 breakdown:\n")
	fmt.Printf("  Cache write:    $%.2f\n", result.F51Detail["cache_write"])
	fmt.Printf("  Cache read:     $%.2f\n", result.F51Detail["cache_read"])
	fmt.Printf("  Uncached input: $%.2f\n", result.F51Detail["uncached_input"])
	fmt.Printf("  Output:         $%.2f\n", result.F51Detail["output"])
}

Output:

Fable 5 cost:    $52.00
Fable 5.1 cost:  $6.31
Savings:         87.86%

Fable 5 breakdown:
  Input:  $50.00
  Output: $2.00

Fable 5.1 breakdown:
  Cache write:    $3.12
  Cache read:     $1.19
  Uncached input: $0.20
  Output:         $2.00

4.4 Five Effort Levels: Cost vs. Quality Trade-offs

Fable 5.1 introduces five effort levels. Thinking is always on and cannot be disabled.

Source: 51CTO hands-on testing (https://www.51cto.com/article/854740.html)

5. Safety Guardrail Overhaul

5.1 False Positive Reduction

The most significant improvement in Fable 5.1’s safety guardrails is dramatically reduced false positive rates:

Source: Anthropic official announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1)

5.2 Guardrail Routing Architecture

User Request
    |
    v
+------------------+
|  Safety Classifier|  ← Cyber & Bio classifiers
+------------------+
    |         |
    | Pass    | Trigger
    v         v
+--------+  +------------------+
| Fable  |  | Fallback to Opus |
| 5.1    |  | Cyber → Opus 4.8 |
| Handle |  | Bio   → Opus 5   |
+--------+  +------------------+

5.3 Policy Changes

• Vulnerability Discovery: Fable 5.1 is now permitted for identifying software vulnerabilities (source code level)
• Exploit Development: Still blocked
• Penetration Testing: Still redirected to Opus models
• Binary Vulnerability Scanning: Still redirected to Opus models

6. Three Real Scientific Case Studies: AI Doing Science Firsthand

Case Study 1: Remapping a Third of Venus

Background: NASA’s Magellan mission in the 1990s collected Venus radar data at 10-20 km resolution. Humanity had completed elevation mapping for only about one-fifth of the planet’s surface.

Fable 5.1’s Contribution: Trained a neural network on publicly available NASA radar data, producing a high-resolution elevation map covering approximately one-third of Venus’s surface, with spatial resolution improved to 2-3 km and elevation accuracy improved by up to 25%.

Output: Released under a Creative Commons license, providing reference data for the upcoming NASA VERITAS and ESA EnVision missions.

Source: Anthropic official announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1)

Case Study 2: Protein Design Hit Rate Approaches 50%

Background: Protein design is the core of biopharmaceutical R&D. Traditional wet-lab screening hit rates typically range from 10-15%.

Mythos 5.1’s Contribution: Using open-source design tools, Mythos 5.1 designed protein binders for 12 targets including EGFR and Nipah G. Two external organizations conducted wet-lab validation:

Source: Anthropic official announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1)

Case Study 3: Hand-Written CUDA Kernels Slash GPU Costs

Background: In genomics and proteomics research, model inference runs thousands of times, creating substantial GPU costs.

Mythos 5.1’s Contribution: Using only public source code, Mythos 5.1 independently wrote CUDA kernels for 7 open-source bioinformatics models on NVIDIA H100 GPUs:

Model Inference Speedup
             Original     Mythos 5.1 Optimized
Evo 2        ████████████ ████            2.5x faster
AlphaFold3   ██████████   █████           2.0x faster
ESM-2        █████████    ██████          1.7x faster
Geneformer   ████████     ███████         1.4x faster

Real Bill Comparison: A genome-wide analysis scanning 3 million variants using Evo 2 dropped from approximately $2,500 to $1,000, a 30-60% reduction in GPU costs.

Source: Anthropic announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1) and third-party coverage (https://aifuturefront.com/anthropic-debuts-claude-fable-5-1-and-mythos-5-1-with-split-safeguards/)

7. API Developer Hands-On Guide

7.1 Basic Call: Python SDK

import anthropic
import os

client = anthropic.Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY")
)

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=16000,
    messages=[
        {
            "role": "user",
            "content": "Design a microservice architecture for a "
                       "real-time data pipeline processing 10TB/day "
                       "with fault tolerance and exactly-once semantics."
        }
    ]
)

# Fable 5.1 always includes a thinking block
for block in response.content:
    if block.type == "text":
        print(block.text)
    elif block.type == "thinking":
        print(f"[Thinking]: {block.text[:200]}...")

# Check for safety refusal
if response.stop_reason == "refusal":
    print(f"Request refused by safety guardrails: {response.stop_details}")

7.2 Five Effort Levels Configuration

def query_with_effort(prompt: str, effort: str = "high"):
    """
    Query Fable 5.1 with specified effort level

    Args:
        prompt: User prompt
        effort: Thinking level: low/medium/high/xhigh/max
    """
    response = client.messages.create(
        model="claude-fable-5-1",
        max_tokens=16000,
        output_config={"effort": effort},
        messages=[{"role": "user", "content": prompt}]
    )
    return response

# Simple tasks use low effort
simple_response = query_with_effort(
    "Summarize this changelog in 5 bullets.",
    effort="low"
)

# Complex research tasks use max effort
deep_response = query_with_effort(
    "Design a novel attention mechanism for long-context "
    "protein sequence modeling with O(n) complexity.",
    effort="max"
)

7.3 Prompt Caching in Practice

import anthropic
from anthropic.types import TextBlockParam, CacheControlEphemeralParam

client = anthropic.Anthropic()

def run_cached_agent_step(
    user_query: str,
    system_instructions: str,
    tool_definitions: list,
    codebase_context: str
):
    """
    Execute an agent step with Prompt Caching enabled

    Fable 5.1 cache read price: $0.25/M tokens (75% off)
    Cache write: $12.50/M tokens (5min TTL)
    """
    system_prompt = [
        TextBlockParam(
            type="text",
            text=system_instructions,
        ),
        TextBlockParam(
            type="text",
            text=f"Tool Definitions:\n{tool_definitions}",
        ),
        TextBlockParam(
            type="text",
            text=f"Codebase Context:\n{codebase_context}",
            # Mark cache boundary on the last block
            cache_control=CacheControlEphemeralParam(
                type="ephemeral"
            )
        )
    ]

    response = client.messages.create(
        model="claude-fable-5-1",
        max_tokens=4096,
        system=system_prompt,
        messages=[{"role": "user", "content": user_query}]
    )

    # Inspect cache hit metrics
    usage = response.usage
    print(f"Input tokens: {usage.input_tokens}")
    print(f"Cache creation: {usage.cache_creation_input_tokens or 0}")
    print(f"Cache read hits: {usage.cache_read_input_tokens or 0}")
    print(f"Cache savings: ${(usage.cache_read_input_tokens or 0) * 0.75 / 1_000_000:.4f}")

    return response

7.4 Three Breaking API Changes (Must-Check Before Migration)

Fable 5.1 introduces three breaking API changes that must be addressed when migrating from Fable 5:

Source: Anthropic docs and third-party compilation (https://www.anthropic.com/claude-fable-and-mythos-5-1, https://devlery.com/en/blog/claude-fable-5-1-cache-read-price)

7.5 Safety Guardrail Fallback Configuration

# Configure fallback models when safety classifiers trigger
# Automatically falls back to Opus models

response = client.messages.create(
    model="claude-fable-5-1",
    max_tokens=4096,
    messages=[{"role": "user", "content": prompt}],
    # Configure fallback strategy
    fallback_models=["claude-opus-5", "claude-sonnet-5"]
)

8. Enterprise Frontier Safeguards (EFS) & Data Privacy

8.1 EFS Architecture

Traditional Approach:
User Data → Anthropic Servers → 30-day Retention → Human Review

EFS Approach:
User Data → Customer's Own Cloud Infrastructure → Customer-controlled Review
            (AWS/GCP/Azure)
                ↓
          Anthropic Automated Monitoring
          (Metadata only, no raw data)

8.2 Key Features

• Zero Data Retention: Data stored in customer-controlled cloud infrastructure
• Customer-controlled Review: Human review done by customer, not Anthropic
• Supported Platforms: Claude Code, Claude Enterprise, Claude Platform, Amazon Bedrock, Google Agent Platform, Microsoft Foundry
• Rollout: Phased rollout starting fall 2026
• Transition: Eligible customers can use Fable 5.1 with zero data retention until EFS is ready

Source: Anthropic official announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1)

9. EU AI Act Compliance & Anti-Distillation

9.1 Invisible Watermarking

Fable 5.1 is Anthropic’s first model subject to EU AI Act transparency commitments. Models released after August 2, 2026 embed invisible text watermarks in outputs. Anthropic is rolling out a detection API in private preview.

9.2 Anti-Distillation Protection

Fable 5.1 introduces chain-of-thought block signature verification:

Distillation Attack:
Attacker: Manually modify context → Extract thinking → Train smaller model

Fable 5.1 Defense:
- API accounts registered after Aug 31, 2026
- Cannot manually modify context mid-conversation
- Modification attempt → API error or thinking block cleared
- All future models will enforce this

Source: Anthropic announcement (https://www.anthropic.com/claude-fable-and-mythos-5-1) and technical analysis (https://blog.csdn.net/viopark/article/details/164295257)

10. Mythos 5.1: Restricted Scientific Capability

10.1 Access Control

Mythos 5.1 is distributed through the following channels:

• Cyber Verification Program (CVP): Cybersecurity defense organizations
• Life Sciences Verification Program (LSVP): Life sciences research institutions
• Current Scope: US organizations only; international expansion coordinated with US government

10.2 Capability Assessment

Source: Anthropic System Card (https://www.anthropic.com/claude-fable-and-mythos-5-1)

11. Developer Decision Framework

11.1 When to Use Fable 5.1?

Recommended for Fable 5.1:
+ Multi-step, long-horizon agent tasks (hours to days)
+ Scientific research data analysis, experiment design
+ Large codebase refactoring, code review
+ High-context-reuse conversation systems

Not recommended for Fable 5.1:
- Single-turn simple Q&A → Use Opus 5 or Sonnet 5
- Latency-sensitive production environments → Evaluate cost trade-off
- Short-context, no-cache calls → May cost more, not less

11.2 Cost Optimization Strategy

Cost Optimization Priority:
1. Enable Prompt Caching (most effective)
2. Choose appropriate effort level (Low/Medium for simple tasks)
3. Use Batch API (50% off input, 50% off output)
4. Control output length ($50/M output is the primary cost driver)

11.3 Migration Checklist

• Search for tool_choice parameters, remove any and tool settings
• Check thinking block compatibility in multi-model chains
• Audit history-editing code paths
• Evaluate cache hit ratio to estimate actual savings
• Configure safety guardrail fallback strategy
• Review data retention policy (30-day vs EFS/ZDR)

12. Conclusion

The release of Claude Fable 5.1 and Mythos 5.1 marks a transition in AI capabilities from “assistive tool” to “firsthand executor.” Venus terrain mapping, protein design, and hand-written CUDA kernels—three case studies point to a clear trend: AI can operate as a front-line scientific researcher, not just an information retrieval tool.

For developers, the 75% cache read price reduction is a direct enabler for deploying long-context agent tasks. For research institutions, Mythos 5.1’s restricted access means this wave of benefits is still in its early stages. But regardless of your role, Fable 5.1 has demonstrated one thing clearly: long-cycle, multi-step AI tasks have finally reached their true “usable” moment.

References

1. Anthropic Official Announcement — Claude Fable 5.1 and Mythos 5.1 https://www.anthropic.com/claude-fable-and-mythos-5-1

2. Anthropic System Card (September 1, 2026) https://www.anthropic.com/claude-fable-and-mythos-5-1

3. CSDN Technical Analysis — Fable 5.1 Deep Dive https://blog.csdn.net/viopark/article/details/164295257

4. 51CTO Hands-on Testing — Claude Fable 5.1 Pricing & Effort Levels https://www.51cto.com/article/854740.html

5. MarkTechPost — Anthropic Releases Claude Fable 5.1 and Claude Mythos 5.1 https://www.marktechpost.com/2026/09/01/anthropic-releases-claude-fable-5-1-and-claude-mythos-5-1-52-6-on-terminal-bench-science-and-75-cheaper-cache-reads/

6. AI Future Front — Anthropic Debuts Claude Fable 5.1 With Split Safeguards https://aifuturefront.com/anthropic-debuts-claude-fable-5-1-and-mythos-5-1-with-split-safeguards/

7. TeachAI Tools — 75% Cut in Prompt Cache Costs Changes AI Agent Economics https://teachaitools.blog/blog/claude-fable-51-mythos-51-prompt-cache-cost-cut-2026

8. Apidog — How to Use the Claude Fable 5.1 API https://apidog.com/blog/claude-fable-5-1-api/

9. Devlery — Claude Fable 5.1 Ships With Identical Input and Output Prices https://devlery.com/en/blog/claude-fable-5-1-cache-read-price

10. Amazon AWS Blog — Introducing Claude Fable 5.1 on AWS https://aws.amazon.com/blogs/machine-learning/introducing-claude-fable-5-1-on-aws/

11. Vercel AI Gateway — Claude Fable 5.1 now available https://vercel.com/changelog/claude-fable-5-1-now-available-on-ai-gateway

12. Yomimono — Anthropic Releases Claude Fable 5.1 and Claude Mythos 5.1 https://yomimono.id/anthropic-releases-claude-fable-5-1-and-claude-mythos-5-1

• ←Previous
• Next→