Claude Fable 5.2

Anthropic's newest frontier model, Claude Fable 5.2, is finally released today, alongside its sibling, Mythos 5.2: the same model with fewer safeguards, available only to vetted organisations (Anthropic, 2026).

The availability and stats as of 10 November 2026 (Anthropic):

Effort sets how much the model thinks before it answers, from low to max. The API default is high (Anthropic), but Claude apps and Claude Code default to medium (Anthropic, 2026).

Cost per token for Fable 5.2 is roughly 20% lower than Claude Fable 5.1 but 2x the price of Opus 5.5. The optional fast mode costs double and gives up to 2.5 times faster output.

USD per million tokens, from Anthropic's pricing page on 10 November 2026 (Anthropic).

I have tested an early version of this model, and it's pretty incredible. Check out Fable 5.2 One-Shotted My Nephew's Dream Game.

Benchmarks

Anthropic reports that Fable 5.2 scored highest on 14 of the 16 results in its summary table, trailing Opus 5.5 only on the GDPval-AA and AA-Briefcase Elo ratings (Anthropic, 2026).

One of the biggest leaps comes via RoboDojo Sim (robotics): an insane 64.9% against 39.4% for Opus 5.5. RoboDojo tests how well a model can control a simulated two-arm robot from camera images (Anthropic, 2026).

The other big jump is the Remote Labor Index, which gives the model real freelance projects and checks its work against a human professional's. Fable 5.2 did 41.3% of them at least as well as a human, nearly double Opus 5.5's 21.3% (Anthropic, 2026).

All results are reported by Anthropic. RoboDojo Sim is from the announcement, with every model run by Anthropic on the same internal harness at its highest effort; it is not in the system card. The rest are from Table 8.1.A of the system card. Fable 5.2 results use max effort averaged over five trials, except FrontierCode (best effort per model: xhigh for Fable, max for Opus 5.5 and GPT-6 Astra) and the Remote Labor Index (default effort). GPT-6 Astra figures come from OpenAI's published results or leaderboards, except OSWorld, which Anthropic ran itself through OpenAI's API.

Independent results

Artificial Analysis puts Fable 5.2 at the top of its Intelligence Index with 65, ahead of Opus 5.5 at 59 (ArtificialAnalysis) (ArtificialAnalysis). But look at the cost: a crazy $26.54 per Index task, the most expensive of the 73 models it has costed, against $10.04 for Opus 5.5. It's also one of the slowest, at 44.1 minutes per task.

Intelligence Index v5.0.1, checked 10 November 2026. Cost per task is each evaluation's token cost divided by its number of tasks, weighted by the evaluation's weight in the Index.

Weight-Space Programming: writing the weights of an MNIST classifier

I reran my 15-step MNIST training test, a follow-up to Weight-Space Programming, on Fable 5.2: the model writes every weight of a 5,994-parameter CNN, then improves them using only the validation loss, accuracy and confusion matrix. It never sees an image or a gradient. Three runs per model at high effort, scored on the official MNIST test set, which the model never sees.

Three runs per model, one conversation each, no retries. Fable 5.2 runs were on 10 November 2026; the others are from the experiments repository. Costs are computed from each response's token usage at Anthropic's list prices. For reference, Adam on the same network reaches 91.8% after 50 gradient steps, and random search with the same number of evaluations about 12%.

At high, every Fable 5.2 run beat every Opus 5.5 and Fable 5.1 run. It isn't cheap, though: despite the 20% price cut, a run cost twice as much as Fable 5.1, because it wrote about 2.4 times as many output tokens.

The prompting guide says Fable 5.2 at low effort scores close to Fable 5.1 at its higher effort levels. Here it did better than that: at low, all three runs beat every Fable 5.1 run at high, and they averaged 76.4% against Opus 5.5's 71.0%, for $5.78 a run.

System card notes

The 264-page system card has a few findings worth knowing about (Anthropic, 2026). They were measured on Mythos 5.2, the same underlying model.

"White-box evidence" suggests it was aware it might be in an evaluation in as many as 43% of automated behavioural audit transcripts.

When told to deliberately underperform without being noticed, it evaded a monitor reading its reasoning in about 1 in 4 attempts, the first model Anthropic tested to do so.

Also, a team of 1,000 agents running an earlier snapshot finished a Lean proof of Fermat's Last Theorem in 30 hours, building on an earlier formalisation.

Prompting changes

Some interesting notes from the prompting guide, which describes how Fable 5.2 behaves differently from earlier models (Anthropic):

Anthropic recommends starting at high effort, the API default, then either going up or down in effort settings, depending on your task.

Apparently, you should say who owns the code. If the prompt doesn't say, or presents the code as someone else's, it adds to the existing structure and reports nearby problems instead of fixing them. Telling it "This codebase is yours" made it merge repeated code in about half the tries, against under a tenth without it, but it also made changes nobody asked for. Anthropic recommends reviewing the diff, not just the summary.

Style rules are followed to the letter. So, if you have a hard limit like "20 words or fewer" per sentence, Fable will follow it and it can make its prose choppy.

Editing earlier turns breaks its thinking. If a harness changes the system prompt, tools or an earlier message, the preserved thinking blocks after that point become invalid and the API returns a 400 error by default.

Real example

As with Claude Opus 5.5, I asked it at high effort to turn this article into a 3D gameshow with an N64 look, using the same prompt.

This uses the Anthropic Python SDK and the Notebook HTML helper, which saves the game and token usage, then renders it. To rerun it, pip install anthropic and the helper, and set ANTHROPIC_API_KEY; the saved game plays without it.

import os
from anthropic import Anthropic
from notebook_html import read_article, render_anthropic_html

api_key = os.environ["ANTHROPIC_API_KEY"]
article = read_article("claude-fable-5-2.md", before="Real example")
with Anthropic(api_key=api_key).messages.stream(
    model="claude-fable-5-2",
    max_tokens=128_000,
    output_config={"effort": "high"},
    system="Return a complete, self-contained HTML document.",
    messages=[{"role": "user", "content": f"""
Turn this article into a 3D gameshow that looks like an N64 game.
Use around 8 questions that test understanding of the article, with a short
explanation after each answer.
Support phones and keyboards. Use inline CSS and JavaScript, no external assets,
network requests or browser storage, and no em dashes. Keep the code compact,
with one shared question renderer.

Article:
{article}
"""}],
) as stream:
    response = stream.get_final_message()
render_anthropic_html(response, "../_media/claude-fable-5-2-quiz-high.html")

Doggo on a bicycle, in 3D

A new test: the same description of my dog I used for the SVG tests, as a 3D model riding a bicycle, in one HTML page with three.js.

import os
from anthropic import Anthropic
from notebook_html import render_anthropic_html

DOG = """A portrait-orientation photo of a black brindle Bull Arab and Staghound cross standing on wet golden sand at the beach on a sunny day. The dog faces the camera, with its head turned slightly towards the left of the frame. It has a white muzzle and grey whiskers, a big black nose, brown eyes, one ear pricked up and one flopped over, and its mouth is open in a happy pant with a long pink tongue hanging out. It wears a red collar with a small round red tag, and has a white patch on its chest. Its legs are long and thin, the front-left paw is white, and the paws are slightly blurred. Its shadow stretches away to the right across the sand. Behind it, white foamy waves wash up the shore, then a band of teal-green sea meets a bright blue sky with scattered white clouds."""

with Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"]).messages.stream(
    model="claude-fable-5-2",
    max_tokens=128_000,
    output_config={"effort": "high"},
    system="Return a complete, self-contained HTML document.",
    messages=[{"role": "user", "content": f"""
Make a 3D model of this dog riding a bicycle, as one HTML page using three.js.
Animate the pedalling, and let me orbit the camera by dragging, with a mouse
or on a phone. Load three.js 0.170.0 and its addons from jsDelivr's ES module URLs, such as
https://cdn.jsdelivr.net/npm/three@0.170.0/+esm and
https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/controls/OrbitControls.js/+esm,
without an import map. Use no other external assets, network requests or
browser storage, and no em dashes.

The dog:
{DOG}
"""}],
) as stream:
    response = stream.get_final_message()
render_anthropic_html(response, "../_media/claude-fable-5-2-doggo-bike.html", height=600)

From the description: 70,463 output tokens, 48,181 of them thinking, for $2.82. For comparison, Opus 5.5's version from the same prompt used 68,840 output tokens, for $1.38.

The same test, but with the photo instead of the description:

import base64, os
from pathlib import Path
from anthropic import Anthropic
from notebook_html import render_anthropic_html

photo = base64.b64encode(Path("../_media/gemini-4-argon-dog-photo.jpg").read_bytes()).decode()

with Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"]).messages.stream(
    model="claude-fable-5-2",
    max_tokens=128_000,
    output_config={"effort": "high"},
    system="Return a complete, self-contained HTML document.",
    messages=[{"role": "user", "content": [
        {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": photo}},
        {"type": "text", "text": """
Make a 3D model of this dog riding a bicycle, as one HTML page using three.js.
Animate the pedalling, and let me orbit the camera by dragging, with a mouse
or on a phone. Load three.js 0.170.0 and its addons from jsDelivr's ES module URLs, such as
https://cdn.jsdelivr.net/npm/three@0.170.0/+esm and
https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/controls/OrbitControls.js/+esm,
without an import map. Use no other external assets, network requests or
browser storage, and no em dashes.
"""},
    ]}],
) as stream:
    response = stream.get_final_message()
render_anthropic_html(response, "../_media/claude-fable-5-2-doggo-bike-photo.html", height=600)

From the photo: 60,466 output tokens, 39,951 of them thinking, for $2.43. It picked up the grey whiskered muzzle and white chest, and added a basket to the bike.

Drawing SVGs

The same two SVG tests as Gemini 4 Argon and Kimi K3.1 Pro: recreate a photo of my dog at the beach, then draw her from a text description alone.

Both were valid SVGs on the first try. From the photo took 1.4 minutes and 6,891 output tokens ($0.28); from the text took 5.6 minutes and 30,084 output tokens ($1.21) (raw results).