Chrome Extension
Anthropic released Fable 5.2 and Mythos 5.2 on Nov 9, 2026, and I built five apps with Fable 5.2 to see what it can do. This Fable 5.2 and Mythos 5.2 review covers the technical details, the benchmarks, what other builders posted on X, and my own tests with one prompt each.
I could only test Fable 5.2, because Mythos 5.2 sits behind verification programs. The result surprised me: the five apps used about 8 percent of my weekly limit on a $200 plan.
Key Takeaways
What Are Fable 5.2 and Mythos 5.2?
Same Model, Different Safeguards
Fable 5.2 and Mythos 5.2 share one underlying model. The difference is the safety layer on top.
Fable 5.2 is generally available. It carries safeguards for cybersecurity and biology, and it hands blocked requests to older models.
Mythos 5.2 has fewer safeguards. You can only reach it through the Cyber Verification Program, the Life Sciences Verification Program, or Claude Security on Enterprise.
What I Tested
I tested Fable 5.2 only. I picked it in the model picker.
That means every score in this review belongs to Fable 5.2. For Mythos 5.2, I rely on Anthropic's published numbers and outside reports, and I label them that way.
Fable 5.2 Technical Details
Specs at a Glance
| Spec | Fable 5.2 |
|---|---|
| Release date | Nov 9, 2026 |
| Claude API model ID | claude-fable-5-2 |
| Amazon Bedrock ID | anthropic.claude-fable-5-2 |
| Google Cloud and Microsoft Foundry ID | claude-fable-5-2 |
| Context window | 1M tokens |
| Max output | 128K tokens |
| Input and output | Text and images in, text out |
| Knowledge cutoff | June 2026 |
| Thinking | Adaptive, always on |
| Effort levels | Low, Medium, High, Xhigh, Max |
| Speed | Output up to 30% faster than Fable 5.1 |
| Retirement | Not sooner than Nov 9, 2027 |
The Fable 5.2 model docs list the IDs, context window, output limit and retirement date. Anthropic's launch page gives the 30 percent speed gain over Fable 5.1.
Pricing
| Per 1M tokens | Fable 5.2 | Fable 5.1 | Opus 5.5 |
|---|---|---|---|
| Input | $8 | $10 | $4 |
| Output | $40 | $50 | $20 |
| Cache read | $0.20 | $0.25 | $0.20 |
| Cache write, 5 min | $10 | $12.50 | $5 |
| Cache write, 1 hour | $16 | $20 | $8 |
| Batch (input / output) | $4 / $20 | $5 / $25 | $2 / $10 |
| Fast mode (input / output) | $16 / $80 | n/a | $8 / $40 |
Every number above comes from Anthropic's pricing page. Fable 5.2 costs 20 percent less per token than Fable 5.1, and it costs twice as much as Opus 5.5.
Effort Levels and Adaptive Thinking
Adaptive thinking is always on, so the model decides how long to think. You control the budget with the effort setting.
The API default is High. Anthropic says Medium is the default in Claude apps and Claude Code.
Anthropic's guidance is to start with High, step up to Xhigh only where your own evals show a gain, and reserve Max for ceiling tests. The docs add that Max runs slower, costs more than Xhigh, and often gains only a small amount.
Fast Mode
Fast mode runs up to 2.5 times faster. The gain is in output tokens per second, not time to first token.
It costs $16 input and $80 output per 1M tokens, which is double the standard price. It does not work with the Batch API or a Priority Tier commitment, and Mythos 5.2 supports it at the same price.
Safeguards and Fallbacks
Anthropic says Fable 5.2's classifiers block high risk cyber activities, including penetration testing and exploit generation. When a query is blocked, you get an answer from Opus 4.8 for cybersecurity and Opus 5 for biology.
Through the API, a blocked request returns a normal response with stop_reason: "refusal". The refusals docs list five categories: cyber, bio, frontier LLM development, reasoning extraction and general harms.
Anthropic says the block rate is about 55 percent lower than Fable 5.1. That works out to about 60 percent fewer blocks in cybersecurity and 40 percent fewer in biology.
The system card adds safeguards for a narrow set of frontier LLM development skills, such as kernel development on certain ML accelerators. Training also included steps to limit research capabilities that could most directly speed up AI development.
Anthropic also says its anti distillation defenses cut harvested data by 90 to 99 percent.
Preserved Thinking and Data Retention
Preserved thinking lets the model reuse thinking blocks you send back from earlier turns. A block stays valid only while everything before it stays unchanged, so treat your message list as append only.
If you edit an earlier turn, Fable 5.2 returns a 400 error by default. Fable 5.2 thinking blocks are also tied to the account that produced them, or to a linked account.
Fable 5.2 requires 30 day data retention, and zero data retention only works if Anthropic expressly authorizes it. Enterprise Frontier Safeguards is in private beta with Bridgewater, Salesforce and Stripe.
API Constraints
The Fable 5.2 docs list a few rules that can break an old integration. Forced tool use, meaning tool_choice types any and tool, returns a 400 error.
You should also omit temperature, top_p and top_k, because some values return a 400 error. Set a large max_tokens at High and above, because it caps thinking plus the reply.
Where You Can Use It
Fable 5.2 runs in the Claude apps on eligible paid plans, the Claude API and Claude Code. It also runs on Amazon Bedrock, Google Cloud and Microsoft Foundry.
Grab Complete AI Stack with 29000+ Prompts, 1200+ Gen AI Prompts, Hundreds of skills pack here;
Fable 5.2 and Mythos 5.2 Benchmarks
Fable 5.2 Against Fable 5.1, Opus 5.5 and Rivals
This table comes from Anthropic's launch page. Anthropic says each score uses the model's highest available effort unless noted.
| Benchmark | Fable 5.2 | Fable 5.1 | Opus 5.5 | GPT-6 Astra | Gemini 4 Carbon |
|---|---|---|---|---|---|
| FrontierCode 2.0 | 49.1% (Xhigh) | 32.4% (Xhigh) | 45.5% | 42.8% | 41.1% (Medium) |
| FrontierSWE v2 | 69.9% | 56.3% | 62.3% | 65.5% | 61.2% |
| AutomationBench | 51.4% | 31.4% | 42.5% | 41.4% | 53.9% |
Terminal-Bench-Science 0.1 | 74.6% | 52.6% | 58.7% | 68.1% | 64.8% |
| OSWorld 2.1 (offline set, partial) | 89.3% | 83.5% | 87.2% | 79.5% | 81.5% |
| RoboDojo Sim | 64.9% | 27.6% | 39.4% | 29.8% | n/a |
AA-Briefcase v1.1 (rubric) | 66.1% | 61.5% | 61.2% | 52.0% | 61.8% |
AA-Briefcase v1.1 (Elo) | 1785 | 1669 | 1800 | 1569 | 1611 |
| Remote Labor Index | 41.3% (High) | 17.9% | 21.3% | 20.8% | n/a |
| Humanity's Last Exam, with tools | 74.2% | 65.6% | 67.7% | 57.2% | n/a |
| WANDR (relaxed score) | 82.1% | 68.7% | 72.3% | n/a | n/a |
| Chartography (no tools) | 73.4% | 44.8% | 64.4% | 71.0% | 72.5% |
BenchCAD 2.1 is not in the table, but its chart caption gives Fable 5.2 a score of 83.5 at Max effort, against 65.3 for Opus 5.5 and 44.4 for Fable 5.1.
The jump over Fable 5.1 is the story here. FrontierCode went from 32.4 percent to 49.1 percent, Remote Labor Index from 17.9 percent to 41.3 percent, and RoboDojo from 27.6 percent to 64.9 percent.
Where Fable 5.2 Does Not Lead
Fable 5.2 does not win everything. Gemini 4 Carbon leads AutomationBench at 53.9 percent, and Opus 5.5 leads the AA-Briefcase Elo score at 1800.
Mythos 5.2 also edges out Fable 5.2 on Terminal-Bench-Science, 75.3 percent to 74.6 percent. The gap is small, which fits two models that share one base.
Mythos 5.2 on Security and Science
Mythos 5.2 posts the biggest gains on security work. These numbers come from Anthropic's launch page, and I did not test any of them.
On the internal CVE Rediscovery evaluation of 1,829 CVEs, Mythos 5.2 found 10.2 percent more vulnerabilities than Opus 5.5 and 14.4 percent more than Mythos 5.1. Anthropic's footnote warns that on CyScenarioBench each lab's scores use unique tasks.
Brian Grinstead, a Distinguished Engineer at Mozilla, said Mythos 5.2 roughly doubled the vulnerability discovery metrics of Mythos 5.1. A customer quote on the same page says one in six confirmed bugs found by Mythos 5.2 were missed by every other frontier model.
Anthropic's automated behavioral audit gives Mythos 5.2 an overall score of 2.67, where lower is better. Mythos 5.1 scored 3.28, Opus 5.5 scored 2.79 and Sonnet 5.5 scored 3.10.
In a sandbox escape test, Mythos 5.2 used outside credentials in 3.1 percent of scenarios. Opus 5.5 did it in 3.3 percent, Mythos 5.1 in 21 percent and Mythos 5 in 39 percent.
What Independent Testers Found
Outside results came in within a day. I read most of them through a Latent Space roundup, and I link each original below.
Artificial Analysis ranks Fable 5.2 at Max effort first on its Intelligence Index v5 with a score of 65. Its post lists Gemini 4 Carbon at 60, Opus 5.5 at 59, GPT-6 Astra at 57 and Fable 5.1 at 49.
The release page shows the effort ladder for Fable 5.2: Max scores 65, Xhigh and High score 62, Medium scores 56 and Low scores 54. Cost per task runs from $3.10 at Low to $26.54 at Max.
Other results point the same way:
GPT-6 Astra.The effort picture is mixed. Artificial Analysis finds Max best, while Vals finds High best, and one analyst reports a dip at max reasoning that only Fable models show.
Is Fable 5.2 50 Percent Cheaper?
No. The per token price is 20 percent lower, and the official pricing table shows it.
The 50 percent figure shows up in three other places, and people mix them up.
First, cost per task. Anthropic's launch page says that on FrontierCode 2.0, Fable 5.2 at High roughly matches Opus 5.5 at Max for about half the cost per task. On WANDR at Medium, it matches Opus 5.5's top score for about 40 percent of the cost.
Second, the low effort results are stronger. On Humanity's Last Exam at Low effort, Fable 5.2 matches Opus 5.5's top score for less than one tenth of the cost per task. On Chartography at Medium, it scores 66.4 percent, ahead of Opus 5.5 at Max with 64.4 percent.
Third, the launch promo. Anthropic says Fable is included for up to 50 percent of weekly usage limits on Pro plans and standard Team seats. Check the current terms before you count on it.
There is a counterpoint. On GDPx, cost per task rose 31 percent from Fable 5.1 to Fable 5.2, from $67.16 to $88.15, even with the cheaper tokens. Artificial Analysis measures $26.54 per task at Max, against $10.04 for Opus 5.5.
So the honest answer is this: tokens got cheaper, but the bill depends on how many tokens the model spends on your task.
What Anthropic Showed at Launch
Anthropic's launch demos aim big, and I treat them as vendor claims.
The headline demo is a prototype operating system. One engineer used Fable 5.2 with more than 1,000 subagents over eight days, and the launch page says it boots on a laptop.
A second demo formalized Fermat's Last Theorem in Lean. Anthropic says a team of about 1,000 Fable 5.2 agents finished in 30 hours, while Opus 5.5 reached 26 percent in 18 hours.
Anthropic's earlier formalization of the theorem took 11 days, and mathematician Kevin Buzzard reviewed that one. I found no independent review of the 30 hour run.
The launch page also describes a production Python to Rust migration that starts about 26 times faster. It cites two black hole physics preprints, and it says Mythos 5.2 accurately modeled 28 of 34 attempted AAV capsid structures.
On hardware, Anthropic links a write up on Claude designing electronics with Diode. It names a speakerphone, a voice assistant hub and a handheld virtual pet, and Diode built the boards straight from the design files.
The prototypes worked without circuit fixes. They have not had electrical validation, thermal testing or certification, so they are still prototypes.
Customer notes add scale. An Uber engineer ran a 10 to 12 hour security audit with Fable 5.2, and Discovered Materials said Fable 5.2 made the Quantum ESPRESSO phonon code about 36 times faster on average on the same GPU.
My Fable 5.2 Tests: 5 Apps, One Prompt Each
How I Set Up the Tests
I used one prompt per app and scored each app out of 5. I picked Fable 5.2 in the model picker.
My apps detect Claude CLI and run on my subscription, so none of them needs an API key.
Test 1: Keyframe, a Motion Graphics Creator
Keyframe is a motion graphics creator. It is not a SaaS app, and it has tools for text, keyframes, shapes and graphs, plus templates.
You can customize everything. In one demo I made a ring with custom keyframes, and the app exports MP4 and animated GIF.
The app detected Claude CLI and showed Fable 5.2 as the selected model. For the test I clicked New, picked typography, and set a 4K shorts size, 10 seconds, 60 fps and a dark background.
Then I asked for a ten second kinetic typography piece with marquee text behind it that says promptslove.com, all in bold.
Build "Keyframe" — a browser-based motion graphics studio. Layers on a timeline, keyframes with
real easing curves, animated text, shapes and charts, and frame-accurate export to video. Plus an
AI that turns a description into an editable animation.
STACK: a tiny local Node/Express server (server.js) that holds the API key, plus a frontend in
public/. Rendering on Canvas 2D (or WebGL2 if you prefer) written yourself — no animation
library. Video export with the WebCodecs VideoEncoder and the mp4-muxer package from jsdelivr.
Projects stored in IndexedDB.
AI: Anthropic Messages API, model "claude-fable-5-2", effort "high" for generating a
composition, "medium" for small edits. Strict tool use with tool_choice {"type":"auto"} for the
structured output ("any" and "tool" return 400). Omit "thinking". Keep refinement chats
append-only — never edit earlier messages, the system prompt, or tools mid-conversation.
You own all of this code. If you notice a problem anywhere, fix it — don't just report it.
═══════════ THE ANIMATION ENGINE ═══════════
- A COMPOSITION has size (presets: 1920×1080, 3840×2160, 1080×1920 for Shorts, 1080×1080),
frame rate (24/30/60), duration, and background
- LAYER types: shape (rect, ellipse, polygon, star, line, path), text, image, SVG import,
group/precomposition, solid, and chart
- Every property is animatable: position, scale, rotation, opacity, anchor point, colour,
corner radius, stroke width, trim path start/end (for "drawing on" lines), blur, glow
- KEYFRAMES with interpolation: linear, hold, cubic-bezier, and spring (with stiffness and
damping), plus named presets (ease in/out, back, bounce, elastic)
- A GRAPH EDITOR showing each property's curve with draggable bezier handles
- PARENTING (a layer follows another), MASKS and track mattes, MOTION PATHS you can draw
- A 2.5D CAMERA: layers can have depth, and a perspective camera can dolly and pan
- TEXT ANIMATION: per-character and per-word animators — typewriter, stagger fade-in, slide up,
scale pop, tracking, wavy — with a stagger amount and order (left/right/centre/random)
- CHART LAYER: paste a small table and get an animated bar, line, or donut chart that grows in,
with labels and value counters
═══════════ THE EDITOR UI ═══════════
Stage in the centre with safe-area guides; a layers + timeline panel at the bottom with
keyframe diamonds, a playhead, zoom, and snapping; a properties panel on the right with a
stopwatch per property; a toolbar on the left. Playback in real time at 60fps for a typical
20-layer composition, scrubbing that's instant, and keyboard shortcuts (space, J/K/L, arrows,
K to add a keyframe). Undo/redo for everything. Dark, focused, pro-tool styling.
═══════════ TEMPLATES (ready-made, fully editable) ═══════════
YouTube intro with logo reveal · lower third · subscribe button pop · kinetic quote card ·
animated bar-chart race · countdown · end screen with two video slots · a 9:16 Shorts hook card
with big captions · a "versus" comparison card (two items side by side — useful for model
comparisons)
═══════════ 🤖 THE AI LAYER ═══════════
1. DESCRIBE AN ANIMATION — e.g. "a 5-second title card: the words 'Fable 5.2 vs Opus 5.5' slam in
one at a time on a dark background, then a thin line draws underneath and a subtitle fades up"
→ the model returns a composition as JSON (layers, properties, keyframes, easings) that loads
onto the timeline, completely editable afterwards. Provide the model with the exact JSON
schema of your composition format in the system prompt.
2. ANIMATE THIS — select a layer and say "make it bounce in", "add a slow drift", "punchier".
3. RETIME — "make the whole thing 2 seconds shorter" or "sync these to the beat markers".
VALIDATE every AI composition: unknown layer types or properties are dropped, numbers clamped,
keyframe times kept inside the duration, fonts limited to a bundled Google Fonts list.
═══════════ AUDIO ═══════════
Import a music or voice track; show its waveform on the timeline; detect beats and place
markers that keyframes can snap to.
═══════════ EXPORT (frame-accurate) ═══════════
- MP4 (H.264) and WebM via WebCodecs at the composition's size and frame rate, with the audio
track included
- PNG sequence (zipped) and an animated GIF for short loops
- Rendering must be OFFLINE and frame by frame — render frame N exactly, encode it, move on —
never a screen recording of real-time playback. A 10-second 4K export must come out with
exactly duration × fps frames and no dropped or doubled frames.
- A progress bar with an estimate, and cancel.
═══════════ WITHOUT AN API KEY ═══════════
The entire editor, templates, and export work fully; only the three AI features are disabled
with a clear note.
═══════════ VERIFY ═══════════
□ Easing curves match the graph editor exactly (a spring overshoots and settles)
□ Per-character text stagger works in every order
□ Exported video has exactly duration × fps frames and matches the preview frame for frame
□ 4K export completes without running out of memory
□ Audio stays in sync in the exported file
□ AI compositions load as normal editable layers and keyframes
□ Invalid AI output is cleaned up or rejected with a clear message, never a crash
□ 60fps playback with 20 layers
Finish every file in this response. Do not stop with a list of remaining work or an offer to
continue. Output all files complete, no truncation, with a README covering setup.The result looked really good. Fable 5.2 placed detailed keyframes at exact seconds, so the text moves on a clear timeline.
My score: 5 out of 5.
Test 2: Leeward, a Sailing Game
Leeward is a sailing game. It has a free sail mode, a cargo run mode, and a third run mode.
Sea animals jump around the boat, a bird flies overhead, and a night vision mode changes the view. The navigation feels neat.
I gave it no artifacts and no 3D structure. Fable 5.2 built every structure from scratch, and I loved it.
Build "Leeward" — a high-fidelity sailing game. Sail a small yacht across an open ocean
archipelago with real wind physics, a beautiful ocean, changing weather, and missions.
ONE self-contained leeward.html. All geometry, textures and audio procedural.
Modern three.js via importmap:
<script type="importmap">
{ "imports": {
"three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js",
"three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/"
}}
</script>
Use SRGBColorSpace, ACESFilmicToneMapping, no deprecated APIs. EffectComposer + bloom allowed.
You own all of this code. If you notice a problem anywhere, fix it — don't just report it.
═══════════ THE OCEAN (the visual centerpiece) ═══════════
- Waves from a sum of 8–16 directional GERSTNER waves with varied wavelength, amplitude,
steepness and direction, all aligned loosely with the wind. Driven in the vertex shader.
- CRITICAL: the exact same wave function must also run on the CPU, so the boat floats on the
waves you actually see. If the boat bobs out of sync with the rendered surface, the build
has failed. Put the wave parameters in one shared object used by both.
- Shading: fresnel blend between a sky reflection and deep-water colour, a subsurface
scattering tint on wave crests lit from behind, sun glint, foam where waves get steep
(compute from the Gerstner Jacobian or crest steepness), lighter turquoise over shallow
reefs near islands.
- A WAKE behind the boat: a fading foam trail plus a bow spray when pushing through waves.
- LOD on the ocean mesh (a camera-following grid with denser vertices near the boat).
═══════════ THE SKY & WEATHER ═══════════
- Procedural atmospheric sky with a moving sun: dawn, midday, sunset, night with stars and moon
- Clouds that build as weather worsens
- WEATHER STATES that change over time: calm, steady breeze, gusty, squall, storm.
Storms bring higher waves, rain on the camera, lightning flashes with delayed thunder,
and stronger, shifting wind.
═══════════ THE SAILING PHYSICS (get this right — it's the whole game) ═══════════
Fixed timestep (120Hz), decoupled from render.
- BUOYANCY: sample the CPU wave height at ~16 points around the hull; each point below the
surface pushes up proportionally to its depth. Plus water drag. This gives pitching, rolling
and surfing down waves for free.
- APPARENT WIND = true wind − boat velocity. The sail only ever feels apparent wind.
- SAIL FORCE: lift and drag from the sail's angle of attack to the apparent wind, with a
proper lift curve that stalls when over-trimmed and luffs (flaps, no force) when under-trimmed.
- KEEL: strong resistance to sideways motion, weak resistance forward. This is what turns
sideways sail force into forward speed. Get it right and these emerge on their own:
* a NO-GO ZONE — the boat cannot sail closer than ~45° to the wind
* a BEAM REACH (wind from the side) is fastest
* running dead downwind is slower than a broad reach
- HEEL: the sail's force tips the boat; the keel weight rights it. Too much wind with the
sheets pulled tight heels the boat hard; easing the sheet spills wind and stands it up.
In a storm you can CAPSIZE if you don't ease or reef.
- RUDDER that only works when water flows past it — no steering when stopped.
- TACKING (turning through the wind) loses speed and needs momentum; GYBING (turning the stern
through the wind) swings the boom across — an accidental gybe slams it over and shakes the
camera.
- Controls: A/D rudder · W/S trim/ease the main sheet · Q/E jib sheet · R reef/unreef ·
Space to hold course. Gamepad supported.
- TELLTALES: small ribbons on the sail that stream straight when trimmed right and flutter
when wrong — a real sailor's cue, and a lovely visual teaching tool.
═══════════ THE WORLD ═══════════
An archipelago of 8–10 procedural islands (noise heightmaps with beaches, cliffs, palms,
lighthouses that sweep at night, a few harbour towns with docks). Reefs in shallow water that
damage the hull. Buoys, dolphins that race the bow, gulls, a shipwreck or two.
═══════════ GAMEPLAY ═══════════
- CARGO RUNS between harbours against a deadline, paid in coins that buy upgrades (better
sails, stronger hull, a spinnaker for downwind speed)
- REGATTAS: race 3 AI yachts around a buoy course. The AI must sail by the same physics —
tacking upwind, choosing a good angle, not driving straight into the no-go zone.
- STORM SURVIVAL: reach a harbour before the storm peaks
- NIGHT NAVIGATION: find an island using only the compass, the stars, and lighthouse beams
- Free sail mode with a weather picker
═══════════ CAMERAS & HUD ═══════════
Cameras (C): at the helm (default, with heel and sway), chase, masthead, cinematic drone.
HUD (minimal, can be hidden): compass, true and apparent wind arrows, speed in knots, heel
angle, sheet trim, and a small points-of-sail diagram showing where you are. Map screen with
islands, harbours and current mission.
═══════════ AUDIO (Web Audio, synthesized) ═══════════
Wind in the rigging pitched by apparent wind speed, waves slapping the hull, the sail flapping
when it luffs, creaking wood under load, rain, thunder, gulls, a calm ambient music bed.
═══════════ VERIFY ═══════════
□ The boat floats exactly on the rendered waves — no visible mismatch
□ The boat cannot sail into the wind; it stalls in the no-go zone
□ A beam reach is faster than close-hauled and faster than dead downwind
□ Easing the sheet in a gust reduces heel; holding it tight in a storm can capsize the boat
□ Telltales stream when trim is right and flutter when it's wrong
□ The rudder does nothing at zero speed
□ AI yachts tack upwind instead of sailing into the wind
□ 60fps at High with the ocean, sky, islands and 3 AI boats
Finish every system in this response. Do not stop with a list of remaining work or an offer
to continue. Output the complete single HTML file, no truncation.My score: 5 out of 5.
Test 3: Sketch to a Working 3D Model
For this test I uploaded a sketch of a van with a sloped roof and a handle. The app turned it into a 3D model that I can orbit around.
When I click a part, the matching part on the other side gets selected and the app shows how its mechanism works. There is also a draw mode.
I added more light and a handle, and the app used Claude CLI to generate the model. Materials switch between wood and cloth, an Explode view lists the components, and the wheels have detail.
The app exports GLB, STL for 3D printing, JSON and PNG.
Build "Codex" — a web app that turns a sketch of an object or machine into an interactive 3D
model. Upload a photo of a drawing (or draw one in the app), and Claude Fable 5.2 reads it and
returns a structured description of the parts. The app builds that as a 3D model, lines it up
over the original sketch, and animates any mechanisms (wheels turn, gears mesh, cranks drive
pistons).
STACK: a tiny local Node/Express server (server.js) that holds the API key and forwards requests,
plus a frontend in public/ (index.html, app.js, styles.css). Three.js via the importmap above
(three@0.170.0) with GLTFExporter and STLExporter. No frontend framework.
AI: Anthropic Messages API, model "claude-fable-5-2", key from ANTHROPIC_API_KEY in .env.
Send the sketch as a base64 image block. Effort "high". For the structured output use strict
tool use with tool_choice {"type":"auto"} — "any" and "tool" return 400 on this model.
Never send "thinking": {"type":"enabled"} or {"type":"disabled"} — omit it.
For refinement chats, keep the conversation APPEND-ONLY: never edit earlier messages, the
system prompt, or the tools list mid-conversation (Fable 5.2 rejects that with a 400).
You own all of this code. If you notice a problem anywhere, fix it — don't just report it.
═══════════ THE SCENE GRAPH (what the model returns) ═══════════
A JSON description of the object as parts:
{
"title": "...", "description": "what the sketch shows",
"view": { "azimuth": deg, "elevation": deg, "distance": n }, // estimated drawing viewpoint
"parts": [ {
"id": "...", "name": "...", "parent": "id or null",
"shape": "box|cylinder|sphere|cone|torus|capsule|gear|lathe|extrude",
"params": { ... }, // sizes; lathe/extrude take a 2D profile as points
"position": [x,y,z], "rotation": [x,y,z], "material": "wood|iron|brass|stone|cloth|rope|glass",
"sketch_region": [x0,y0,x1,y1] // where this part is in the image, 0–1
} ],
"mechanisms": [ {
"type": "rotate|slide|crank|gear_mesh|belt",
"driver": "part id", "driven": ["part ids"],
"axis": [x,y,z], "ratio": n, "range": [min,max]
} ],
"notes": "anything unclear in the drawing"
}
VALIDATE everything before rendering: every parent and mechanism refers to a real part, no
cycles in the hierarchy, all numbers finite and within sane ranges, and unknown fields dropped.
If validation fails, show what failed and offer to retry — never crash.
═══════════ THE 3D VIEW ═══════════
- Build each part from its shape. GEAR generates real teeth from tooth count and radius.
LATHE spins a profile; EXTRUDE pushes a 2D outline.
- Materials that read as the named material (warm wood grain, dark iron, polished brass),
with soft lighting and an environment map.
- MECHANISMS RUN: a play button animates every mechanism. Gear meshes turn at the right
ratio and in opposite directions; a crank drives its piston back and forth; wheels on an
axle turn together. This is the moment that sells it.
- OVERLAY MODE: the original sketch fills the background and the 3D model is drawn on top,
lined up using the estimated viewpoint. A slider fades between sketch and model, and the
user can nudge the alignment by dragging.
- EXPLODED VIEW: parts slide apart along their hierarchy, with labels.
- Hover a part: it highlights in 3D AND its region is outlined on the sketch, with its name.
═══════════ EDITING ═══════════
- Click a part to edit its size, position, material, or delete it
- Plain-English refinements ("make the wheels bigger", "add a second gear driven by the first",
"the arm should be longer") sent with the current scene graph; the response replaces it
and the change animates in
- Undo/redo across both manual edits and AI edits
- A built-in DRAW mode: a simple canvas with pen, eraser, and undo, so a sketch can be made in
the app instead of photographed
═══════════ EXPORT ═══════════
GLB (for other 3D tools), STL (for 3D printing), the scene-graph JSON, and a PNG of the overlay.
═══════════ WITHOUT AN API KEY ═══════════
Ship 3 sample sketches drawn procedurally as SVG — a hand cart, a windmill with a gear train,
and a crank-and-piston engine — each with a pre-made scene graph, so the whole app (3D view,
overlay, mechanisms, editing, export) works with no key. Only new sketch reading needs one.
═══════════ UI ═══════════
A calm studio layout: the sketch on the left, the 3D view on the right (or overlaid), a parts
list and properties panel, and the refinement box. Parchment and ink tones, a notebook feel.
Clear loading state while the model reads the drawing.
═══════════ VERIFY ═══════════
□ A photographed sketch of a simple machine produces a recognisable 3D model
□ Every part's highlight lines up with the right area of the sketch
□ The overlay alignment is close before any manual nudging
□ Meshing gears turn in opposite directions at the correct ratio
□ Bad or partial JSON from the model shows a clear error and a retry, not a crash
□ Refinement edits keep the conversation append-only and don't 400
□ GLB and STL exports open in a standard viewer
□ The 3 samples work with no API key
Finish every file in this response. Do not stop with a list of remaining work or an offer to
continue. Output all files complete, no truncation, with a README covering setup.This one blew my mind. It was one prompt and one go, and I saw no room for errors.
My score: 5 out of 5.
Test 4: A Train Journey Front End Website
For this test I supplied no images and no 3D objects. I also used no Unsplash photos and no open source assets.
Fable 5.2 built a landing page with a scroll animated train and track, an interactive map and station info. It also built a reserve my cabin flow with dates, berth names, a corridor, a guest name and a summary.
The site adds a dining menu, stations, carriages and a custom cursor. I did not describe most of these parts, and Fable 5.2 added them on its own.
Build "Nocturne" — the website for a luxury overnight sleeper train that crosses a continent.
A complete MULTI-PAGE site: 6 interlinked pages, one design system, one nav, and transitions
between pages. It must be IMMERSIVE and ANIMATION-HEAVY: the homepage IS the journey — scrolling
carries the visitor through a night on board, from departure at dusk to arrival at dawn.
STACK: three.js via the importmap above (three@0.170.0, modern API only), GSAP 3.12 +
ScrollTrigger, Lenis smooth scroll, Lucide icons, Google Fonts. All imagery procedural (canvas,
SVG, WebGL) — no external image files.
FILES:
shared.css · shared.js
index.html · journeys.html · carriages.html · dining.html · stations.html · book.html
js/home.js · js/journeys.js · js/carriages.js · js/dining.js · js/stations.js · js/book.js
You own all of this code. If you notice a problem anywhere, fix it — don't just report it.
DESIGN DIRECTION — "art deco by lamplight":
Dark-first. Midnight navy, polished brass, warm amber window light, cream for text, a muted
claret for accents. Fonts: an art-deco display face (geometric, high-contrast, for headings),
a refined humanist sans for body, and a mono for timetables and platform numbers. Deco line
ornaments, brass rules, subtle fan and sunburst motifs. Warm, slow, cinematic.
CUSTOM CURSOR: a small lantern — a warm glowing dot whose soft light gently brightens whatever
is near it on the page (a radial reveal on background textures and ornaments). On hover over
links it flares slightly. Hidden on touch devices.
PAGE TRANSITIONS: a TUNNEL — the screen darkens from the edges as if the train has entered a
tunnel, a few streaks of light rush past, then the new page emerges into light.
═══════════ PAGE 1 — index.html: THE JOURNEY (the showpiece) ═══════════
The entire page is one continuous scroll-driven journey, ~12 sections long:
- HERO (dusk departure): a real Three.js scene of the train at a grand station platform —
a sleek deco locomotive and carriages, warm-lit windows, steam drifting under station
lamps, a departures clock. As the visitor starts scrolling, the train pulls out.
- THE JOURNEY BAND: as the visitor scrolls, the train travels left to right through a
sequence of landscapes built from layered PARALLAX scenery (5–7 depth layers per landscape),
and a SKY whose colour is driven by "journey time" — sunset orange → violet → deep night
→ pre-dawn blue → golden sunrise. Landscapes, in order:
1. City lights fading behind
2. Open plains with fireflies and a rising moon
3. A mountain pass with falling snow and a stone viaduct
4. A lakeside where the moon reflects and the train's windows reflect in the water
5. Forest at the darkest hour, the windows the only light
6. Coastal cliffs at sunrise, the sea catching first light
The train's windows show tiny passenger silhouettes (reading, dining, sleeping as the night
goes on). Window light spills onto the ground beside the tracks. The moon and stars move
across the sky. A small ROUTE MAP in the corner draws the line as you travel, with a clock
showing the hour.
- Between landscapes, content sections fade in over the journey without stopping it: the
cabins, the dining car, the observation car, a guest quote, the route, the numbers (km,
hours, stations, cabins — animated counters), a FAQ, and the booking call to action at
sunrise.
Make this feel continuous. No hard cuts between landscapes — they blend into each other.
═══════════ PAGE 2 — journeys.html ═══════════
A SPLIT-FLAP DEPARTURES BOARD at the top (the classic railway board whose letters flip
through the alphabet to land on each word) listing routes, times, and platforms — it flips
when the page loads and when filters change. Route cards with duration, season, and price
from; an interactive SVG map where routes draw themselves on hover; filters by season and
length; a featured seasonal journey.
═══════════ PAGE 3 — carriages.html ═══════════
A cutaway view of the train — an isometric or 3D cross-section of each carriage type
(Grand Suite, Cabin, Dining Car, Observation Car, Bar). Hovering any area reveals labelled
details. A DAY/NIGHT toggle in the cabin view animates the room transforming: the sofa
folds out into a made bed, the lamps dim, the blinds come down, stars appear outside the
window. Comparison table of cabin classes.
═══════════ PAGE 4 — dining.html ═══════════
The dining car by candlelight (flickering warm light on the tablecloths). A tasting menu
presented course by course as you scroll — each course "served" with a gentle reveal. The
chef, the wine list with regional notes that follow the route, breakfast at sunrise.
═══════════ PAGE 5 — stations.html ═══════════
The destinations, each as an illustrated vintage POSTCARD that flips over on click to show the
back (a handwritten-style note, a postmark, a stamp). Station details, local highlights, best
season, an arrival-time line.
═══════════ PAGE 6 — book.html ═══════════
A multi-step booking flow: route → date (a calendar showing availability) → cabin (choose a
specific berth on a carriage seat map) → passengers → summary. On confirmation, an animated
TICKET prints out, gets a conductor's hole punched in it, and slides into an envelope.
Validated, keyboard-accessible, with clear errors.
SHARED SYSTEMS (shared.js): Lenis + a brass progress rule; the lantern cursor; theme toggle
(a lighter "daylight" theme for reading-heavy pages) persisted in localStorage; [data-reveal]
entrance system with slow eased reveals; gentle magnetic buttons; tilt cards with a brass
sheen; the tunnel page transition; a shared split-flap component used on two pages.
REQUIREMENTS: frosted-brass nav after scroll, active page indicated, mobile overlay menu, fully
responsive (the journey still works on a phone, with fewer parallax layers), reduced-motion
respected (the journey becomes a sequence of still scenes), accessible (semantic HTML, focus
states, aria labels, decorative art hidden from screen readers), 60fps target, pixel ratio
capped at 2, WebGL fallback to a static illustrated hero. Route names, times, and prices must be
consistent across every page.
DELIVERY: shared.css and shared.js complete first, then each page with its JS. Finish every page
in this response. Do not stop with a list of remaining work or an offer to continue. No
truncation. End with a validation checklist.My score: 5 out of 5.
Test 5: Primordia, a Simulator of Evolving Bugs
Primordia is a simulator of bugs that evolve on their own. You can add new species.
Charts track fitness, species over time and average body size. Playback speed goes up and down, with slow motion for the detail.
Build "Primordia" — a 3D evolution simulator. Random creatures made of nodes and muscles are
dropped into an environment. The ones that move best breed; over generations, their bodies and
gaits evolve on their own. ONE self-contained primordia.html (Web Workers created from inline
Blob URLs are fine). Modern three.js via the importmap above. Write the physics yourself.
You own all of this code. If you notice a problem anywhere, fix it — don't just report it.
═══════════ THE CREATURE PHYSICS (write it yourself) ═══════════
Creatures are soft-bodied: NODES (point masses with radius and friction) joined by BONES
(rigid distance constraints) and MUSCLES (springs whose rest length changes over time).
- Verlet integration with constraint solving, fixed timestep, several solver iterations
- Ground contact with friction that depends on each node's friction gene — grip is how
creatures push themselves forward
- Muscles contract and relax under control (below). Contraction is what moves the creature.
- FULLY DETERMINISTIC: the same genome in the same environment must produce exactly the same
run, every time. This matters because evaluation happens in workers and the replay you watch
must match the score it got.
- Stable: creatures must not explode, tunnel into the ground, or fly off from numeric errors.
- EXPLOIT DETECTOR: evolution is famous for finding physics bugs (gaining energy from nothing,
vibrating through the floor). Track each creature's energy; flag and disqualify any that
gain energy without pushing off the ground, and log it in an "Exploits found" panel. If your
physics has a hole, evolution will find it — and showing that on screen is a feature.
═══════════ THE GENOME ═══════════
- BODY GENES: node count (3–12), node positions, sizes, friction; which pairs are joined by
bones vs muscles
- BRAIN GENES: per muscle, either a simple oscillator (period, phase, amplitude) OR a tiny
neural network that reads sensors (ground contact per node, body tilt, a clock signal) and
outputs muscle targets. Let the user pick "oscillator" or "neural" mode.
- MUTATIONS: nudge values, add or remove a node, add or remove a muscle, switch a bone to a
muscle. CROSSOVER between two parents.
═══════════ EVOLUTION ENGINE ═══════════
- Population 100–500 (slider). Each generation:
1. Evaluate every creature for N simulated seconds, headless, spread across Web Workers in
parallel (navigator.hardwareConcurrency)
2. Score by the chosen goal
3. Keep the best, breed the rest with tournament selection, apply mutations
- SPECIATION: group similar genomes into species and give each its own breeding share, so a
new body plan isn't wiped out before it's had time to improve (NEAT-style)
- Speed: the user picks "watch every generation" or "fast-forward 50 generations" with only
the champions replayed
- GOALS (fitness functions): walk the furthest, jump the highest, swim the furthest, climb stairs,
and "move while carrying a ball"
═══════════ ENVIRONMENTS ═══════════
Flat plain · rolling hills · stairs · shallow water (drag and buoyancy, swimming emerges) ·
low-gravity moon · icy surface (low friction). Changing environment mid-run should visibly
force the population to re-adapt.
═══════════ THE VIEW ═══════════
- Render creatures as soft, cute organisms: smooth tube-like bodies around the bones and
muscles, nodes as rounded joints, muscles glowing when they contract. Colour by species.
- The current champion runs centre stage with a follow camera; a "parade" view shows the top
10 side by side with distance markers.
- Ground with distance lines, soft shadows, a pleasant sky.
═══════════ DATA & TOOLS ═══════════
- Charts (hand-written SVG): best / median / worst fitness per generation, number of species
over time (a stacked area chart), and average body size
- FAMILY TREE: click any creature to see its ancestors back to generation 0
- HALL OF FAME: the best creature from each milestone, replayable
- DESIGNER: build a creature by hand (click to place nodes, drag to connect) and drop it into
the population
- Sliders: population, mutation rate, simulation time per test, gravity, muscle strength
- Save/load runs; share a creature via a compact URL hash; export the champion's genome as JSON
═══════════ VERIFY ═══════════
□ The same genome gives the identical score in a worker and in the on-screen replay
□ Best fitness clearly rises over 50+ generations on the walking goal
□ At least two different body plans appear over a long run (speciation is working)
□ Swimming creatures evolve in water and walkers don't automatically succeed there
□ No creature explodes or sinks through the floor; the exploit detector catches energy gain
□ Worker evaluation actually runs in parallel (check generation time vs. one worker)
□ 60fps while showing the champion with evolution running in the background
Finish every system in this response. Do not stop with a list of remaining work or an offer
to continue. Output the complete single HTML file, no truncation.My score: 5 out of 5.
My Cost and Limits
I am on a $200 plan. My weekly limit sat at 47 percent before the tests, and the five apps used about 8 percent of it.
That is one data point from one plan. I did not measure speed, and I did not run the same prompts on Opus 5.5.
Where Fable 5.2 Falls Short
Cost Per Task Can Go Up
The 20 percent token discount does not guarantee a cheaper task. SemiAnalysis measured a 31 percent rise in cost per task on GDPx, and Artificial Analysis measured $26.54 per task at Max.
Theo ran a game build called Fishslop that took 76 minutes and cost about $42. He called the result not significantly better than Opus 5.5, especially for the price.
He also estimates that a $200 Ultra subscription buys about $15K of Opus 5.5 usage but only about $3K of Fable 5.2.
Slow and Token Hungry for Routine Work
Dan Shipper of Every graded Fable 5.2 overall S and coding S plus. He gave knowledge work an S for people who rethink how they work and a B for routine use, with design at A and writing at B to B plus.
The BigGo write up of his review says he finds it too slow, too expensive and too token hungry for everyday tasks. His team lead, Kieran Klaassen, suggests Opus 5.5 for interactive work and Fable 5.2 for long hand off tasks.
Every receives free tokens as part of its early model access, and Shipper discloses it.
Max Effort Is Not Always Better
Anthropic's own effort docs say Max often gains only a small amount and tell you to reserve it for ceiling tests. Vals found High beat Xhigh and Max, and one commenter flatly advised against using Max.
Artificial Analysis still scores Max highest, so test your own tasks before you pay for it.
Safeguards Block Some Work
Anthropic says Fable 5.2's safeguards block most cybersecurity tasks. A Reddit commenter objected that this could limit legitimate security work.
Anthropic points that work to Mythos 5.2 through the Cyber Verification Program.
Claims Without Outside Review
The 30 hour Fermat's Last Theorem formalization, the operating system demo and the capsid modeling are vendor claims. I found no independent checks yet.
I would wait for outside reviews before I repeat any of them as fact.
What People Are Building With Fable 5.2 on X
I read through the first day of Fable 5.2 posts on x.com. These are the builds I found most useful, with a screenshot of each post.
I paraphrase every post and link the original, so you can check the details yourself.
The Launch Posts From @claudeai
The main launch post pulled about 12.1M views. It is the post that told most people Fable 5.2 and Mythos 5.2 exist.
Source: @claudeai launch post on X
The follow up on hardware devices pulled about 273K views. It describes specs, components, four layer boards, 3D printed enclosures and software for three devices.
Anthropic says each design was ready for manufacture in under a day and all three worked without modification.
Source: @claudeai hardware post on X
Riley Brown: A Blender Room in 52 Minutes
Riley Brown asked Fable 5.2 for a Blender room from one prompt. The result had 13 camera shots, rendered in 4K on 10 GPUs on RunPod in 52 minutes.
The render cost $5.75, and he added music and sound effects with ElevenLabs. I would show this post to a friend first, because it ends in a finished video instead of a code listing.
Source: Riley Brown on X
Felix Rieseberg: A One Shot FPS Called Saltline
Andrew Curran quoted a post from Felix Rieseberg about a first person shooter called Saltline. Fable 5.2 built it in one shot, with no human feedback, in about 8 hours.
The post lists 2.7M output tokens and 445M input tokens, and says most of the input was cached. The total came to about $550, which is the number I would remember when someone calls Fable 5.2 cheap.
Source: Andrew Curran on X
Shikhar: A Bugatti Tourbillon in Blender
Shikhar built a Bugatti Tourbillon in Blender from one prompt plus reference images. The post says Fable 5.2 modeled every part, including the interior, then rendered a cinematic, all in 2.5 hours.
Cars make a hard test because proportions expose every mistake. That makes this one worth a close look.
Source: Shikhar on X
Thomas Werner: Couch Tennis With a Phone Racket
Thomas Werner built Matchball, a couch tennis game where your phone acts as the racket. He says it took about 2 hours.
The idea is small, fun and easy to picture.
Source: Thomas Werner on X
Higgsfield: The Saltfire Racing Game
Higgsfield posted Saltfire, a Three.js racing game with 5 meter seas, homing rockets and 5 AI rivals. It is a promotion, because the Higgsfield MCP offers a 3 day free Fable 5.2 trial.
I include it because the game looks good, but read it as marketing.
Source: Higgsfield on X
MarkTwainBrother: Neo Tokyo 2099 in One HTML File
MarkTwainBrother built Neo Tokyo 2099 in a single HTML file with Three.js. It has more than 30 neon signs, rain, flying cars and clickable signs.
The post had only about 14 views when I captured it. Good work sits in small accounts too.
Source: MarkTwainBrother on X
Artificial Analysis: The 3D Arena Result
Paper quoted an Artificial Analysis result for its AA-3D benchmark, which ranks AI built interactive 3D experiences. Fable 5.2 at Max scored 1271 Elo, ahead of Sonnet 5.5 at 1204 and Opus 5.5 at 1202.
The test tiles include a Taj Mahal, a dragon, a Starship, a pelican on a bicycle, an octopus with a drum kit and a dodgeball scene.
Source: Paper on X
Other Builds I Saw
Choblin and Sun Xiang shared the operating system demo and a code built 3D world. Anika posted a GPU history, and Preetam Das wrote a thread of builds.
Atomic Agent showed Fable as the boss with a local Qwen model as the builder, and claimed it cut cost and time. Treat that one as a vendor promo.
What These Builds Have in Common
Most posts follow one pattern: one prompt, a long agent run, and a finished artifact such as a video, a game or a 3D model.
The costs range from $5.75 to about $550. The budget depends on how long you let the agent run, not on the price per token alone.
Fable 5.2 vs Opus 5.5: Which Should You Use?
Anthropic tells you to start with Opus 5.5 for most tasks. The model docs recommend Fable 5.2 for demanding reasoning and long horizon agentic work, or when Opus 5.5 at higher effort still falls short on your evals.
Smaller models can also consult Fable 5.2 through Advisor, and Fable can run a team of smaller models through orchestration. That lets you spend Fable tokens only where they matter.
| Situation | Better pick |
|---|---|
| Daily coding, edits and chat | Opus 5.5 |
| Big builds from one prompt, like my five apps | Fable 5.2 at High |
| Long agent runs with many subagents | Fable 5.2 |
| Hard math, science or hardware design | Fable 5.2 |
| Cheap, simple or high volume tasks | Sonnet 5.5 or a smaller model |
| Security research and penetration testing | Mythos 5.2 through a verification program |
For work like my five apps, I would try Fable 5.2 first. For everyday edits, I would stay on Opus 5.5.
Frequently Asked Questions (FAQs)
What is the difference between Fable 5.2 and Mythos 5.2?
They share the same underlying model but differ in safeguards. Fable 5.2 is available on eligible paid plans, the API and Claude Code, and its classifiers block high risk cyber and biology requests. Mythos 5.2 has the same specs and pricing but is limited to organizations verified through programs such as the Cyber Verification Program.
How much does Fable 5.2 cost?
Fable 5.2 costs $8 input and $40 output per 1M tokens, based on the official pricing page. That is 20 percent below Fable 5.1 and double Opus 5.5. Batch runs cost $4 and $20, and fast mode costs $16 and $80.
Is Fable 5.2 better than Opus 5.5?
On Anthropic's launch table, Fable 5.2 wins most tests, including FrontierCode 2.0 at 49.1 percent against 45.5 percent. Opus 5.5 still costs half as much per token, and Anthropic tells you to start with it for most tasks. Theo found Fable 5.2 not significantly better on one build.
Which effort level should I use for Fable 5.2?
Anthropic's effort docs say to start with High and move up only where your evals show a gain. Claude apps and Claude Code default to Medium, and the API defaults to High. Max is for ceiling tests, because it runs slower and often gains only a small amount.
Can I use Fable 5.2 in Claude Code?
Yes. Claude Code's model configuration docs explain how to pick a Fable model, and Anthropic says Medium is the default effort there. Fable 5.2 also runs in the Claude apps on eligible paid plans, the API, and on Amazon Bedrock, Google Cloud and Microsoft Foundry.
Why did Fable 5.2 block my cybersecurity request?
Anthropic says the classifiers block high risk cyber activities, including penetration testing and exploit generation. Through the API, a blocked request returns a refusal with a category, and the refusals docs explain how to set up a fallback model. For security research, go through the Cyber Verification Program to use Mythos 5.2.
Final Thoughts
Fable 5.2 earned five 5 out of 5 scores from me, and for big builds I think it is the best model out there right now. The per token price fell 20 percent, but your bill still depends on effort and task length, so watch your limits.
Mythos 5.2 is a security and science tool that most people cannot reach, and I did not test it. Pick one build you care about, run it on High, and compare both the result and the cost against Opus 5.5.
