TL;DR: Anthropic released Claude Fable 5 on June 9 (the first public Mythos-class model, a tier above Opus) at $10/$50 per million tokens, included on Pro/Max plans until June 22. I pointed three projects at it overnight. The biggest observation: handed a one-line brief, it ran the repo’s governance process like it wanted to be there. The framework forces that structure on any model, and earlier models produced it too; the difference was how little it needed me. The other observation is token burn. These turn out to be the same thing.

Anthropic released Claude Fable 5 on June 9. The next day I switched the agent sessions on three of my projects over to it and let them run overnight. By morning the three repos had pushed somewhere around forty PRs through their usual review gates and merged them. The most productive thing I did that night was sleep.

Two things worth writing down: what Fable 5 actually is (the “Mythos-class” label needs unpacking), and the two differences I noticed on day one compared with running the same projects on Opus.

What is a Mythos-class model?

Claude used to come in three tiers: Haiku, Sonnet, Opus. Mythos-class is a new tier stacked above Opus. The first Mythos model was April’s Mythos Preview, available to a small set of partners through Project Glasswing. This release brings two more: Claude Fable 5 and Claude Mythos 5.

Per the announcement, they’re the same underlying model with different safeguards. Fable 5 is the public one: when its classifiers trip on high-risk topics (cybersecurity, biology and chemistry, model distillation), the response is automatically handled by Claude Opus 4.8 instead, which Anthropic calls “a far better experience than an outright refusal.” Per their numbers, over 95% of sessions never see a fallback. Mythos 5 lifts some of those safeguards and goes only to authorized cyberdefenders and biomedical researchers.

Put plainly: Fable 5 is the Mythos that’s been made safe to hand to everyone. I suspect the names are doing exactly that work: Mythos as the source text, Fable as the version you can tell the public. I couldn’t find an official explanation, so take that as a guess.

TechCrunch’s headline was pointed about the timing: Anthropic had spent the preceding days warning that AI is getting too dangerous, then shipped its most capable model to the public. The safeguard-plus-fallback design is presumably their answer to that tension. Whether it convinces anyone is a separate question, but it is at least a structured answer.

What does Fable 5 cost?

$10 per million input tokens, $50 per million output. Anthropic says that’s less than half of what Mythos Preview cost (Preview pricing was never public, so that one you take on their word), and it’s still the most expensive tier in the Claude family. The 5x output-to-input ratio is the part that matters for agent workloads. Agents are never short on output.

One date to put in your calendar: from June 9 through June 22, Fable 5 is included on Pro, Max, Team, and seat-based Enterprise plans at no extra cost. On June 23 it leaves those plans and moves to usage credits. So right now there’s a two-week free window, and this post is partly just a reminder that it exists.

Day one: it takes the governance process seriously

One of the projects I handed it is a virtual-office side project governed by agentic-os. Governance here means something concrete: a written set of working rules in the repo. Open a work log before touching code, write a spec, pass a series of checks before claiming anything is done. My brief was roughly one sentence: “do what helps the project’s process — make it stable.” It expanded that sentence into a dozen-plus numbered backlog items, organized them into a hardening wave and a stability wave, and worked through them in priority order. Each item got its own work log and spec, archived on completion, with a closeout at the end of each wave. I checked the progress once in the middle of the night and it read less like a model running a task and more like a PM executing a schedule.

Before this turns into an ad, a brake. Expanding a one-line brief into registered waves is not a Fable 5 trick: the first seventy-odd backlog items in that repo were cleared the same way by earlier models under the same governance, and the old work logs even show multi-lens review panels striking down most of a feature’s proposed scope. The framework was designed to force exactly this behavior out of whatever model is running. The commit history says the same thing — there were twenty-commit days back in May; the Fable day was thirty. A bump, not a different world. And strictly speaking I have no control group: I didn’t run Opus in parallel on the same brief, so read this as a day-one impression, not a benchmark.

So where’s the difference? The model’s contribution and the framework’s are tangled together, so I’ll stick to the part I’m sure of. With earlier models I did the dragging: they’d skip the work log, edit files directly, declare completion without evidence — that’s why the gates exist at all. This time it read like the model wanted to be on the rails: my one middle-of-the-night progress check found nothing waiting on my judgment, and neither did the morning. Nights like that used to leave a pile of decisions for breakfast. “Barely needed me” is the only difference I’m prepared to put my name on.

One small case I liked: a visual request — stop characters from walking through each other. It reviewed the idea from three lenses, concluded the fix would cost more than it was worth, declined to build it, and filed an ADR recording the reasoning and the conditions for reopening. I was the requester, and my own model turned me down. The framework has always allowed that. I can say the rejection was hard to argue with.

In a second repo, a file-hashing bug: it patched the spot I pointed at, then went back three more rounds and cleared out the entire family of related corruption, writing its own commit message about killing the whole class of problem. Watching it dig, I felt no urge to take over.

The announcement claims “the longer and more complex the task, the larger Fable 5’s lead,” with a Stripe case study about compressing a 50-million-line Ruby migration from months into days. I usually skim past big-company case studies, and my one day pointed in the same direction. One balancing note: that same day, in the agentic-os repo itself, I still upgraded the work-log lock from advisory to blocking. The model behaving well is not a reason to dismantle the gates.

And the first thing I had the third project do after the model swap: re-baseline its entire behavioral eval suite against the new model. Swap the model and your old test assumptions break — a habit that comes from no evidence, no completion. The suite came back all-but-one green, and the one failure traced to a stale assumption in the test itself, not the model. However smart the new model is, I’m not skipping that step.

The token bill is real

The flip side of all that thoroughness is usage. Longer tasks, self-spawned subagents, reviewing its own changes. Every layer is tokens.

A concrete data point: I’m on Max 20x. The interface has an Effort slider, Faster to Smarter, with an honest little note that higher effort uses your limits faster. Running Fable 5 I had it at High (not even maxed out) and the five-hour usage window still emptied almost immediately. Inside the free window my wallet hasn’t felt it, but hitting the ceiling on a 20x plan is not something that used to happen to me.

I worked through the cost side of this in Token Economics of AI Agent Governance; the conclusion then was that governance overhead pays for itself. Fable 5 raises the unit price and the volume at the same time, so after June 23 that math needs redoing. Which tasks are worth Mythos-class prices and which should fall back to Opus or Sonnet is about to become everyone’s homework.

When I wrote about Claude Code’s dynamic workflows I noted that doing a thing inside a workflow costs visibly more than doing it in conversation. Fable 5 essentially makes that tendency its default personality: it wants to do the big, complete version of everything, and both the benefit and the bill come from that.

What I’d try before June 22

While it’s included in Pro/Max anyway: pick a task you’d normally slice into three days of work yourself — not “fix this function,” but “get this project’s test health in order” — and hand it over whole. Watch how it expands the brief. It tells you more than any benchmark table.

Two things I want to try next: what Fable 5 feels like in plain Claude Code with no governance framework around it, and whether Effort below High is still worth using. If you get there first, I’d genuinely like to hear how it goes.