Anthropic released Claude Fable 5.2 and Claude Mythos 5.2 on 9 November 2026. They’re built for long, hard technical work like big migrations, deep debugging and multi-agent research. This guide covers what changed, what it costs, when you should (and shouldn’t) use it, and how to call it from Python.

What Anthropic Announced

According to the official announcement:

  • Fable and Mythos are the same underlying model. Fable ships with strong cybersecurity and biology safeguards, so it’s open to everyone. Mythos is for organisations approved through Anthropic’s Cyber and Life Sciences Verification Programs.
  • Speed: Fable 5.2 and Mythos 5.2 produce output up to 30% faster than the 5.1 versions.
  • Price: $8 per million input tokens and $40 per million output tokens, which Anthropic says is lower than before.
  • Fast mode: an optional mode that generates tokens up to 2.5 times faster, at $16 per million input tokens and $80 per million output tokens.
  • Availability: on the Claude Platform as claude-fable-5-2, and on Amazon Web Services, Google Cloud and Microsoft Azure.
  • GitHub Copilot: GitHub’s changelog says Fable 5.2 is generally available for Copilot Pro+, Max, Business and Enterprise users. Business and Enterprise admins have to turn on the policy first, because it’s off by default.

When Fable is the right pick

Anthropic is clear that Fable isn’t meant to be your default model. For most coding and knowledge tasks, it recommends starting with Claude Opus 5.5. Move up to Fable when a task is too big or too open-ended, or move down to Sonnet 5.5 or Haiku 5.5 when it’s simple. Anthropic also describes two ways to use Fable inside a larger system:

  • Advisor: a smaller Claude model consults Fable when it gets stuck on a hard problem.
  • Orchestrator: Fable plans the work and hands simpler subtasks to smaller models.

Safeguards you should know about

Fable 5.2 uses classifiers that block high-risk cybersecurity work, such as exploit generation and penetration testing, and most research-biology tasks. When a query is blocked, you get an answer from a different model instead: Opus 4.8 for cybersecurity or Opus 5 for biology. Anthropic says early testing showed about 55% fewer blocks than Fable 5.1. If you build security tooling, plan for this. Either apply for Mythos access or route those tasks somewhere else.

The announcement also says preserved thinking now applies to all accounts. This anti-distillation feature stops clients from editing Claude’s earlier reasoning in the context. If your integration rewrites or trims past assistant turns, check Anthropic’s preserved-thinking docs before you upgrade.

Step 1: Install the SDK and Set Your Key

The examples below use Anthropic’s official Python SDK.

python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install --upgrade anthropic
export ANTHROPIC_API_KEY="sk-ant-..."   # Windows PowerShell: $env:ANTHROPIC_API_KEY="sk-ant-..."

Step 2: Your First Fable 5.2 Request

A basic Messages API call looks the same as with any other Claude model. Only the model ID changes.

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from the environment

message = client.messages.create(
    model="claude-fable-5-2",
    max_tokens=2000,
    system="You are a senior backend engineer. Be concise and concrete.",
    messages=[
        {
            "role": "user",
            "content": (
                "We have a Flask monolith with 40 routes and a single Postgres DB. "
                "Propose a step-by-step plan to split out the billing module "
                "into its own service without downtime."
            ),
        }
    ],
)

print(message.content[0].text)
print("input tokens:", message.usage.input_tokens)
print("output tokens:", message.usage.output_tokens)

The usage block tells you exactly how many tokens you were billed for. Log it from the start, because Fable’s output price is five times its input price.

Step 3: Stream Long Answers

Fable often writes long answers to big tasks. Streaming shows the text as it’s generated, so users aren’t left staring at a spinner.

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-fable-5-2",
    max_tokens=4000,
    messages=[{"role": "user", "content": "Review this migration plan for risks: ..."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    final = stream.get_final_message()

print("\n\noutput tokens:", final.usage.output_tokens)

Step 4: Estimate Cost Before You Scale

Here’s a small helper that uses the published list prices, so you can compare standard mode with fast mode before running a batch job. These are the prices from the announcement. Check Anthropic’s pricing page before you rely on them.

# Prices in USD per million tokens, from Anthropic's 9 Nov 2026 announcement
PRICES = {
    "standard": {"input": 8.00, "output": 40.00},
    "fast": {"input": 16.00, "output": 80.00},
}

def estimate_cost(input_tokens: int, output_tokens: int, mode: str = "standard") -> float:
    p = PRICES[mode]
    return (input_tokens / 1_000_000) * p["input"] + (output_tokens / 1_000_000) * p["output"]

# Example: 200 code-review jobs, ~30k tokens in and ~4k tokens out each
jobs = 200
for mode in ("standard", "fast"):
    total = jobs * estimate_cost(30_000, 4_000, mode)
    print(f"{mode:>8}: ${total:,.2f}")

For this example, that comes to $80.00 in standard mode and $160.00 in fast mode. Fast mode makes sense when latency matters, for example when a developer is waiting on the answer. For overnight batch jobs it usually doesn’t.

Step 5: Route Tasks Instead of Defaulting to Fable

Anthropic’s own advice is to start lower and move up only when needed. A simple router puts that into code. Keep model IDs in environment variables so you can change them without redeploying, and copy the exact Opus, Sonnet and Haiku IDs from Anthropic’s models documentation.

import os
import anthropic

client = anthropic.Anthropic()

MODELS = {
    "hard": "claude-fable-5-2",
    "default": os.environ.get("CLAUDE_DEFAULT_MODEL", ""),  # e.g. your Opus 5.5 model ID
}

def ask(prompt: str, difficulty: str = "default", max_tokens: int = 1500) -> str:
    model = MODELS.get(difficulty) or MODELS["hard"]
    resp = client.messages.create(
        model=model,
        max_tokens=max_tokens,
        messages=[{"role": "user", "content": prompt}],
    )
    return resp.content[0].text

# Cheap, everyday task -> default model
print(ask("Write a docstring for a function that slugifies a title."))

# Open-ended, multi-step task -> Fable
print(ask("Design a zero-downtime plan to move 2 TB from MySQL 8 to Postgres.", "hard", 4000))

Effort Levels and Fast Mode

Anthropic’s benchmarks show Fable 5.2 at several effort levels (Low, Medium, High, Xhigh and Max). Medium is the default in the Claude apps and Claude Code. Anthropic says Fable 5.2 at High effort scored about level with Opus 5.5 at Max effort on its FrontierCode 2.0 evaluation, at roughly half the cost per task. The exact API parameters for effort and fast mode are in Anthropic’s API reference, so copy them from there rather than guessing. Fast mode is available on Claude Code, the Claude Platform, Claude Models on Google Cloud, and Microsoft Foundry (Anthropic hosted).

Practical Checklist

  • Log usage.input_tokens and usage.output_tokens on every call.
  • Set a sensible max_tokens. Output tokens are the expensive part.
  • Use Fable for ambiguous, long-running work. Use cheaper models for routine work.
  • Expect security and biology requests to be blocked or rerouted on Fable.
  • If you trim or rewrite conversation history, check the preserved-thinking docs.
  • For Copilot Business or Enterprise, ask your admin to enable the Fable 5.2 policy.

Takeaway

Claude Fable 5.2 is faster and cheaper than 5.1. You switch to it just by using the model ID claude-fable-5-2. Treat it as a specialist: keep everyday traffic on a cheaper default model, send the hard, open-ended jobs to Fable, and track tokens from day one. Full details are in Anthropic’s announcement.