All articles

Claude Fable 5.2: models are now judged on visuals

Anthropic's biggest model: a shooter in eight hours, and a pull request Opus would have written the same way

Anthropic shipped Claude Fable 5.2 and Claude Mythos 5.2 today, November 9. I read the announcement and the guide that came with it, and the number that stuck with me isn't about Fable. On FrontierCode 2.0, Opus 5.5 at max effort scores 45.5% and Fable 5.2 at high scores 45.3%, with Opus at roughly half the cost per task. For everyday code, the flagship no longer gives you anything Opus doesn't. The gap still shows somewhere else, and you can see it with your eyes: animation, 3D scenes, whole games.

Fable and Mythos are one model behind two doors

Anthropic says it plainly: there is a single model underneath. What changes is who gets in.

• Fable 5.2 is generally available, with tighter safeguards on dangerous biology and cybersecurity requests.
• Mythos 5.2 is limited to organizations vetted through the Life Sciences and Cyber Verification programs. Anthropic says it found more vulnerabilities than any of its previous models.

If you write code, Fable is the one you get. It costs $8 per million input tokens and $40 per million output, down from $10 and $50 for Fable 5.1. That's 20% off. Cache reads sit at $0.20, same as Opus 5.5, and output comes up to 30% faster than the previous version. One million tokens of context and 128K of output, same as Opus.

On everyday code, the gap is gone

Back in September, writing about Opus 5.5 and its pricing, I said I struggled to find a reason to pay two and a half times as much for Fable 5.1. With 5.2 the multiplier drops to two, and the argument still holds. Anthropic's own guide to picking a model calls Opus 5.5 "our daily driver for complex coding" and puts the numbers next to it: Fable 5.2 and Opus 5.5 land two tenths apart on FrontierCode, with Opus at half the cost.

The same thing is happening on the other side. OpenAI pitches GPT 6.1 Sol as nearly matching GPT 6 Astra on agentic coding at a fifth of the price: $2 and $10 per million tokens. Most of those numbers are OpenAI's own, and Sonar's independent test trims them: more tasks passed than GPT 6 Sol, but more total bugs to triage. The direction holds anyway. The model that's good enough for code gets cheaper every quarter.

There's a condition, and it isn't in any table. The error margin is tiny if the person on the other end knows what they're asking for. You write the spec. You read the diff that comes back. You spot the wrong abstraction that passes every test. And you stop the agent when it's working very hard on the wrong problem. Put a stronger model in the hands of someone who can't do that, and you get wrong code that looks more convincing.

When Fable is worth paying for: the big migration and the run nobody watches

The same guide is candid about where Fable earns its 2x. Its task table gives Fable 5.2 "major refactors and migrations, architecture planning, and leading many subagents", and says to move up when "Opus 5.5 at high still falls short, or for long unattended runs". The example is concrete: Fable migrates a whole codebase to TypeScript, then Opus 5.5 builds the feature on top.

Here's how I read it:

• the ticket, the bug, the feature across three PRs: Opus 5.5;
• the legacy app nobody has touched in years, the framework three majors behind, the migration that would eat weeks of a team's time: Fable 5.2.

That's where double the price pays for itself, because the job is a plan that has to hold for hours and keep dozens of subagents on track. On a thirty-minute task you pay double for the same diff.

The benchmark that matters now is one you watch

When two models land at 45.3 and 45.5, the table stops telling you which one to pick. The tests that still separate models are moving to places where you can see the output.

MotionGraphicsBench, posted to arXiv on November 7, asks a model to animate a static SVG from a written request, across 100 cases checked by deterministic programs. Over 32 models, pass@1 runs from 6.0% to 67.7%: a sixty-point spread, where coding benchmarks are decided by decimals. Then there are informal comparisons, like this one on pixel-art animations between Opus 5.5, GPT 6 Astra and Gemini 4 Argon: Canvas 2D, procedural audio, and a verdict you reach by watching.

The demo that traveled furthest is Saltline. Felix Rieseberg, an engineer at Anthropic, asked Fable 5.2 for a first-person shooter: "Insanely detailed quality pls, something that looks visually like it can keep up with AAA". One level, a container port in the rain, three relays to cut. Models, sounds and textures were all generated from scratch.

Full size

He posted the numbers himself on X: about 8 hours and $550 at API pricing, 445 million input tokens and 2.7 million output, heavily cached. And you can play it in the browser.

Getting the game is no longer the hard part. The bill and the scope are. If you build frontends, this is closer than it sounds: the hero animation, the 3D scene on the landing page, the motion work you used to hand to a designer. That's exactly the kind of work where these models now differ.

What stays in my setup

Opus 5.5 stays my default in Claude Code. I haven't turned Fable 5.2 on for a project of mine yet, and I'm in no hurry. I'll reach for it the day a legacy app lands that needs to jump three majors, or a client wants a 3D scene on the landing page without a studio budget. That's where double the price shows up in the result, not just on the invoice.