A Conductor at Double the Rate: Claude Fable 5 and the New Economics of AI Intelligence

On June 9, 2026, Anthropic did the thing it had called too dangerous as recently as April: it put a Mythos-class model on general release. For five months that class lived behind the barbed wire of Project Glasswing — cyber defenders, government agencies, an access list shorter than the guest list at a private wedding. Now it has been groomed, fitted with safeguards, named Claude Fable 5 — and given a price tag: $10 per million input tokens, $50 per million output tokens. Exactly double Opus 4.8. And within a day, every work chat I sit in surfaced the same question: "so, are we switching?"

Wrong question — and what makes it interesting is why it's wrong. It belongs to the era when AI was a chat window: one model, swapped like a phone. That era ended quietly, without an obituary. AI has become an expensive operational resource — like compute, like people, like a credit line. And you don't "choose" an expensive resource. You allocate it. Fable 5 is not a replacement for your daily model. It's a conductor let down into the orchestra pit: brilliant, plays every instrument better than the musicians. But if you're paying the conductor's rate for the triangle part — the problem isn't the rate. The problem is you.

What landed on the table

Numbers first, otherwise this is press-release enthusiasm. SWE-Bench Pro — 80.3% against 58.6% for the nearest competitor. Humanity's Last Exam — 53%, seven points above the previous record. Stripe, on early access, handed Fable 5 a migration across a 50-million-line Ruby codebase — a two-plus-month manual job for a whole team. The model closed it in a day. One tester fed it a 15-page design document and watched it work nine hours straight — no nudging, no "remind me what we're doing." Simon Willison, who tests every major model faster than the press release ships, put it dryly: slow, expensive, churned through everything he threw at it. Not a sprinter — a marathoner with a heavy pack.

And to understand why this model shipped in a muzzle rather than with a generic "safety policy" disclaimer: its predecessor, Mythos Preview, in the hands of roughly fifty Glasswing partners, found more than ten thousand high- and critical-severity vulnerabilities in the world's most systemically important software. This is not a marketing tier. This is a class of model that shifts the balance of power in cybersecurity — in both directions.

Hence the fine print, worth reading before it reads you:

Safeguards with a stand-in. Fable 5 is Mythos 5 in a muzzle: the same model, but requests about cyberattacks, biology/chemistry, or distillation attempts get intercepted by classifiers and quietly handed to Opus 4.8. On average — under 5% of sessions, and you're notified. But averages lie the way sticker prices do: if your work is security or biology, the fallback can fire on nearly every request, sometimes the very first one — the classifier reads your repository context and CLAUDE.md too. Which makes for a special kind of black comedy: the model that became a legend through cybersecurity demotes you to Opus precisely on cybersecurity. You bought a Ferrari, pulled onto the autobahn — and the car says: "for your safety, engaging Toyota Corolla mode." Not a bad car. Just not the one you opened the champagne for.

The window closes June 23. Until June 22, Fable 5 is included in Pro, Max, Team, and seat-based Enterprise at no extra cost. After that — usage credits only, "until capacity allows." Translated from corporate: two weeks of tasting, then the till. The heaviest items in your backlog belong on the table now.

30-day retention. Anthropic keeps all Mythos-class traffic for 30 days — for safety, not training, with every human access logged. Most people won't care. If your compliance is retention-sensitive — that's a checklist item.

The new economics: the token lies, the task doesn't

Prices as of June 10, 2026:

Model	Input, $/1M	Output, $/1M	Context	Role
Fable 5	$10	$50	1M	conductor: the longest, hardest missions
Opus 4.8	$5	$25	1M	senior: deep synthesis, complex code
Sonnet 4.6	$3	$15	1M	the workhorse: 80% of daily work
Haiku 4.5	$1	$5	200K	the intern-courier: mass small jobs at speed

On top of the rates sit three multipliers that matter more than the rates. Prompt caching: re-sent context costs ~10% of input price; writing to cache costs +25%. Batch API: anything that can wait up to an hour gets minus 50% on both input and output. Effort: the depth dial, covered below.

There is an old economics of AI: "which model is best?" And there is a new one: "which is the cheapest model that closes this task without coming back to me?" These are different civilizations. In the first, people buy the smartest model, throw everything at it — and then ask Reddit why their Max plan burned down before lunch. That's not a hypothetical: within the first week, posts appeared in the spirit of "Fable is eating my Max 20x plan at 2% per minute." People weren't afraid of the per-token price. They were afraid of the usage meter, which had turned into a progress bar of death. In the second civilization, people build routing — and not just the geeks: corporations are already putting AI "on a diet," introducing token budgets, caps, and routing policies, because compute bills stopped being a rounding error in the P&L. The romance is over; the accounting has begun. A small grave for everyone who "just throws it at the best model."

Let's price not an abstract "one pass" but four recognizable jobs — from "sort out an email" to an overnight migration:

Model	$/1M	Email 10k/1k	Module 100k/10k	Landing 500k/60k	Migration 5M/500k
Haiku 4.5	$1/$5	$0.015	$0.15	$0.80	not its league
Sonnet 4.6	$3/$15	$0.05	$0.45	$2.40	$22.50
Opus 4.8	$5/$25	$0.08	$0.75	$4.00	$37.50
Fable 5	$10/$50	$0.15	$1.50	$8.00	$75

This table reads in two registers at once. Left to right — machinery: Haiku is a moped, Sonnet is a long-haul truck, Opus is a locomotive, Fable is a harbor gantry crane. Top to bottom — a diagnosis. Sorting an email with the crane is convening a full professorial consilium to take your temperature. They'll take it. Accurately. Recorded in triplicate, signed, stamped — thirty seconds of work, rounds at nine. A landing page on Fable is Goldman Sachs structuring your shawarma purchase: the deal will close, with due diligence and a data room. The shawarma will be cold. But the overnight migration — that's finally honest work for the crane: when it lifts a container, it's majesty. When it lifts your laptop bag, it's an HR training video about inefficiency. Boom — and $75 for a migration a team would have done by hand over a month suddenly looks not like an expense but like the cheapest line in the budget. Bam — and those same $0.15 per email, multiplied by a thousand emails a day, become $150 of daily tribute to your own ego, because a wedding pâtissier is scrambling your morning eggs.

And now the main trick that makes the price column lie. A token is not a unit of productivity. It's a unit of friction. If Sonnet closes a hard refactor in four iterations with your edits in between — that's $1.80 plus your evening. If Fable closes it in one pass — $1.50, and the evening is yours. On the right task, the most expensive model per token is the cheapest per outcome. And if you spent three times the tokens to get a prettier version of the same "almost there" — you just paid for premium fog. With nice indentation, though.

It's not a model. It's a team

The most useful routing frame is a staffing one. Haiku is the intern with a checklist: fast, cheap, doesn't need telling twice — but don't ask it to think. Sonnet is a solid individual contributor you can hand a module and walk away. Opus is the senior you call when you need judgment, not hands. Fable is a fractional CTO: you don't ping them every seven minutes — you give them a problem, authority, and a deadline.

Print this and tape it to the monitor:

Task	Who	Why
Classification, tagging, extraction, moderation	Haiku + Batch	thousands of small calls: you need speed at $1/M, not brains
Short translations, captions, templated emails	Haiku	rigid format, zero variance
Daily coding, single-module refactors, tests	Sonnet	best price/intelligence balance; make it your Claude Code default
Drafts, single-document analysis	Sonnet	does it as well as its elders at a third of the bill
Subagents, parallel “hands” in orchestration	Sonnet / Haiku	cheap hands under an expensive lead
Cross-document synthesis, architecture decisions	Opus 4.8	reasoning quality is the bottleneck, not token count
Complex code review, flaky bugs	Opus 4.8	finds more real bugs, says honestly when unsure
Overnight autonomous mission from one spec	Fable 5	hours unsupervised; the longer the task, the bigger the lead
Codebase migration, multi-repo refactor	Fable 5	the Stripe case: months compressed into a day
Hard vision: screenshots → code, charts → data	Fable 5	the new state of the art, near-zero scaffolding
Root-cause investigations, outage debugging, error cost >> token cost	Fable 5	investigates before acting and verifies itself

The mechanics are simple: default at the bottom of the pyramid, escalate deliberately. Not "which model is best" but "which is the cheapest one that will definitely manage." And yes, this is already baked into the tools: Claude Code ships an opusplan mode — Opus thinks in planning mode, Sonnet executes. Expensive brain for the plan, cheap hands for the code. Staffing policy, not a devotional choice of "the best."

Effort: a gearbox, not a gas pedal

The second dial after model choice is the effort parameter: how much the model thinks and acts. Five positions: low, medium, high, xhigh, max. The common mistake is treating it as a gas pedal: "floor it, it'll get smarter." It's a gearbox: each gear fits its own road, and in fifth gear you stall in the parking lot.

Facts first, because everyone gets these wrong. The default is high: on Fable 5, Opus 4.8, Opus 4.6, and Sonnet 4.6 (the single exception is Opus 4.7, where the default is xhigh). The xhigh level exists only on Fable 5 and Opus 4.7/4.8 — Sonnet 4.6 simply doesn't have it; its ladder ends at high and max. And Fable 5 is not the default model anywhere: in Claude Code you turn it on by hand, /model fable.

Level	Motto	Typical tasks	Red flag
low	”do exactly this”	classification, extraction, short translations, real-time chat, subagents with a narrow spec	under-thinks on mid-size tasks: the spec must be precise
medium	”fast and decent”	drafts, summaries, single-file fixes, routine agent pipelines; the recommended default for Sonnet 4.6	on some tasks it equals high in quality, faster — test on yours
high	”the work suit”	regular coding, analytics, longreads, multi-document synthesis — the default almost everywhere	almost none: the starting point you calibrate from
xhigh	”the mission” (Fable 5, Opus 4.7/4.8 only)	multi-hour agentic runs of 30+ minutes, complex refactors, deep search	needs a large max_tokens (64K+), or it cuts the thought mid-sentence
max	”the ceiling, time doesn’t matter”	proofs, research hypotheses, a production heisenbug, audits of critical code, one-shot with no second try	overthinking and diminishing returns; in Claude Code it only persists for one session — that’s a hint

A nuance that rewires intuition: on Fable 5 the lower gears are stronger than they sound — low and medium on Fable often outperform xhigh on previous models. The intelligence ceiling moved up, so "frugal Fable" is not "dumb Fable." Anthropic's own advice is to start at high and calibrate, not reflexively push up.

Three questions instead of deliberating which gear to engage. First: is a human waiting synchronously? If you're staring at a spinner — the ceiling is high. Max can reason for tens of minutes: nothing for an overnight run, an eternity for a dialogue. Second: is intelligence the bottleneck? If the task is constrained by format, speed, or volume — low/medium, no hesitation. Third: is the cost of an error orders of magnitude above the cost of tokens and time? Only then, max.

When higher effort makes things worse

This is not a theoretical risk — it's documented behavior. At max, the model is prone to overthinking: it second-guesses itself, adds defensive abstractions nobody asked for, builds a temple where a shelf needed hanging. On structured tasks with a strict format, higher effort can produce a worse result — more "creativity" exactly where discipline was needed. Same for creative writing: a model that has second-guessed itself three times writes worse than it would have on the first confident pass.

And in money: an answer at high is roughly 3–8 thousand tokens of reasoning; at max — 20–60 thousand. On Fable 5 output costs $50/M, so a single max turn can eat $1–3 of pure "thinking" and a quarter-hour of your waiting. A hundred requests a day — $100–300 and hours of waiting, for a gain that on most tasks you couldn't tell from high without a magnifying glass. Max effort for a Telegram caption is calling the fire brigade because the kettle boiled. And max-by-default without any measurement is premium self-harm: expensive, slow, and with the warm feeling that you're doing everything right.

The mirror rule works too: if the model "hangs in thought" over something simple — don't write "don't think too long." Shift down a gear. That's what the dial is for. And remember effort isn't only about thinking: a lower level means fewer tool calls, less preamble, terser replies; a higher one makes the model more eager to search, verify, run tests. You're adjusting its appetite for work, not the length of its monologue.

One last touch: the relationship is non-monotonic. On agentic tasks, higher effort often makes the total bill cheaper — a smarter plan upfront, fewer iterations. On a share of tasks, medium delivers exactly what high does, faster. The only honest way to find out where yours sits is to run the same task at medium/high/xhigh and compare. Tedious. Works.

Seven rules that cut the bill

1. Route down by default. Set Sonnet as the default and switch up by hand, deliberately. That one setting halves a typical bill with zero loss on the everyday.

2. One complete brief instead of twenty nudges. Fable 5 is trained to work from the outcome: describe what "done" means, the constraints, the criteria — and let go. Every mid-session "oh, and also..." is a fresh round of reasoning over the entire context at full rate. Expensive models love silence.

3. Effort is a gearbox. The grid is above. Short version for the monitor: high daily, xhigh for missions, max only where an error costs more than time and tokens combined.

4. Don't break the cache. Caching is a prefix match: one changed byte at the start and the whole cache burns. The classic is a timestamp baked into the system prompt: every request is "unique," cache hits are zero. Prompt caching with a timestamp in the system prompt is financial self-immolation in an enterprise jacket. Stable content first, volatile content last.

5. Everything non-urgent goes to Batch. Minus 50% for an hour's patience. An overnight classification of 10,000 documents on Haiku via Batch — about three dollars. The Batch API is a washing machine: if you're hand-washing every t-shirt in real time, that's not craftsmanship. That's a cult.

6. Expensive conductor, cheap hands. Fable or Opus plans and decomposes; parallel subagents on Sonnet and Haiku execute. You pay for brains where brains are needed. Claude Code itself is built this way — its search subagents have long been running on Haiku.

7. Memory goes into files, not into context. Anthropic measured it: file-based notes improved Fable 5's performance in a long-horizon game three times more than Opus 4.8's — the model knows how to keep a notebook and use it. Why this works — a separate section below.

The counter-thesis: when Fable makes things worse

Now the most important part, because so far this text has been too optimistic. The most expensive model doesn't cure bad task management. It makes it more expensive, faster, and far more convincing.

If you don't know what "done" means, Fable won't close the task. It will ceremonially build a temple around your vague spec — with columns, tests, a README, and a small chapel for the burned tokens. Everything will look like progress. If the spec is garbage, Fable won't turn it into a strategy. It will produce premium garbage with documentation.

Four honest lines instead of romance:

Right task + complete spec = Fable saves money.
Vague spec + ping-pong = Fable multiplies chaos at double the rate.
Long context without structure = an expensive landfill.
Max effort without evals = premium self-harm.

Fable makes sense where three conditions meet: a long horizon, a high cost of error, a clear definition of done. Translating a short email? Haiku. A Telegram caption? Haiku — or Sonnet, if you really want to feel like a writer. "Come up with ten names"? Sonnet. "Analyze two hundred pages of contracts, find the risks, compare against company policy, and produce a redline"? Now you call in the heavy artillery. If only one of the three conditions holds — that's not strategic use of frontier intelligence. That's deluxe procrastination: the same move as buying a Herman Miller to finally "get serious about Notion."

Context is not memory. It's a garage

A million-token context window is easy to mistake for memory. It's a trap, and an expensive one.

Context is what the model sees right now. Memory is information that is structured, tersely written, updated, and retrieved at the right moment. The difference is the same as between "it's somewhere in my garage" and "I know where it is." Researchers documented the "lost in the middle" effect long ago: models use the beginning and end of a long context best, and the middle — where you buried "that important PDF" — much worse. A million tokens without structure is handing someone the company's entire archive in boxes and saying "the answer's in there somewhere." It really is. Right next to a 2021 deck, three "final_final_v3"s, and a file nobody was supposed to create.

1M context is not memory. It's a suitcase with no handle — except now they also bill it at $10 per million tokens. That's why file-based memory, notes, summaries, and short state files matter more than "just throw it all into context." Fable handles long horizons better than any predecessor — but that's not an indulgence for digital hoarding. Even a genius thinks worse when you've buried his desk in junk and asked him to "just be smart about it."

The Unix rule

Hacker culture has known this for decades: don't fire up a heavy system where grep, awk, and a healthy disgust for unnecessary complexity will do. You don't need Kubernetes to rename three files. You don't need Fable to extract an email address from a letter. You don't need max effort for the model to say "thanks, got it."

A good AI workflow is a Unix pipeline: small cheap tools do small precise things, and expensive intelligence plugs in only where you need a plan, judgment, or synthesis. Otherwise you're not building a system. You're starting a chainsaw to slice butter.

Anti-patterns: how to burn a budget beautifully

Fable as a pricier chat. The most popular method. Trivia, questions, chit-chat — the conductor will play the triangle too, flawlessly, at double the rate. Fable on trivia is a neurosurgeon who brilliantly carried your boxes upstairs. The boxes are fine. The budget isn't.

Ping-pong. The most expensive way to work with this class of model: every line of yours makes it reason anew over all the accumulated context. You're not collaborating with a genius — you're making him re-read "War and Context" every five minutes.

Dead context. Attachments you pinned "just in case" that now ride along in every request. Every file lugged into context is rent you pay on every single turn.

Max-by-default. See the effort section. In short: you're not "squeezing out the maximum," you're paying for your own anxiety.

Measuring in tokens. Measure in tasks: what it cost to close, iterations and your time included. A cheap model that closed the task beats an expensive model that wrote you a beautiful obituary for the budget.

The end

"Should we switch to Fable 5?" is a question from the previous era. There's nowhere to switch to. There's a tier to build on top.

In the new economics of AI, the winner isn't whoever always picks the smartest model. The winner is whoever allocates intelligence: cheap hands at the bottom, strong judgment at the top, and the genius only on tasks where he actually changes the outcome. Haiku hauls boxes. Sonnet assembles modules. Opus thinks about the hard parts. Fable takes what's been lying in the backlog like radioactive debris: migrations, audits, tangled systems, long autonomous missions, tasks with no third attempt.

The worst thing you can do with Fable is use it as a premium chat. It's heavy machinery. Called out for every little thing, it will do everything beautifully — and somewhere in the corner, the budget will quietly die. Not every task deserves a conductor. Some need a drummer. Some need an Excel filter and a small pill for ambition.

So the right question isn't "should we switch." The right question is: which tasks in my system are scary, expensive, or long enough to deserve a conductor? The honest answer is almost always unpleasant from both ends: fewer than your ego wants — and more than your cowardly habit of finishing everything by hand allows.

Take the trivia away from the genius. And the scariest task — finally hand it over.