Anthropic launched Claude Fable 5 yesterday. It's the first model in a new tier above Opus — the first "Mythos-class" model made generally available — and I've spent the last day reading everything published about it and poking at it through the API and Claude Code.

I've been writing about context management since February. About how context loss quietly breaks sessions. About how the major platforms manage agent memory. About why agent teams need explicit context boundaries the same way human teams do. The closing line of the context wars post was: context is a resource that needs to be managed, not a bucket that needs to be bigger.

Fable 5 is the strongest validation of that argument I've seen from any platform. Here's why.

What actually launched

The facts first, because the launch had several moving parts.

Fable 5 is positioned above the Opus family — a new tier, not an Opus increment. Pricing is $10 per million input tokens and $50 per million output, exactly double Opus 4.8. It's available immediately via the API (claude-fable-5) and Amazon Bedrock, and it's included free for Claude Pro, Max, Team, and Enterprise subscribers from June 9 through June 22.

The benchmark numbers are significant where they matter most for agentic work: 80.3% on SWE-Bench Pro against Opus 4.8's 69.2%, 88% on Terminal-Bench 2.1, and 64.5% on Humanity's Last Exam with tools. The headline capability claims are about long-horizon autonomy — working unattended for longer stretches than any previous Claude model — and about staying focused across very long contexts.

The more unusual part: Fable 5 is the same underlying model as Claude Mythos 5, which Anthropic is releasing only to a small group of cyberdefenders and infrastructure providers through a US government collaboration called Project Glasswing. Fable 5 is the public version, with safeguards that reroute sensitive queries to Opus 4.8 instead — triggered in under 5% of sessions, per Anthropic.

Pause on that last sentence, because it's quietly remarkable: the safety architecture is an orchestration pattern. Anthropic is running model-level routing in production — one model handing specific categories of work to another based on policy. That's the same separation-of-concerns logic I've been describing for agent teams, applied by the platform to itself.

The context window didn't grow — and that's the point

Fable 5 ships with a 1M token context window and up to 128K output tokens. Opus 4.8 has a 1M window and 128K output. A new model tier, double the price, the company's biggest capability jump in a year — and the context window stayed exactly where it was.

Two years ago that would have been the headline disappointment. Today it barely gets mentioned, because the window arms race genuinely is over. What Anthropic spent its effort on instead is the management layer, and the list is worth walking through.

Token efficiency went up while capability went up. Anthropic reports Fable 5 is more token-efficient than Opus 4.8 despite being substantially more capable. That's the opposite of what we've been trained to expect — bigger models historically thought longer and rambled more. A model that does more with fewer tokens is doing better context management internally, not just externally.

Task budgets make pacing explicit. When I compared platforms in March, the thing that set Claude apart was token budget awareness — the model knowing how much room it has left and pacing its work accordingly. That's now a first-class API feature: you give the model a total token budget for an entire agentic loop, and it sees a running countdown and self-moderates — prioritizing, cutting scope, wrapping up gracefully as the budget drains. This is different from max_tokens, which is a hard ceiling the model never sees. One is a wall the agent runs into; the other is a deadline the agent plans around. Anyone who has managed a delivery program knows these are not the same thing.

Server-side compaction handles the long tail. For conversations that approach the window, the API summarizes earlier turns automatically and keeps going. This is the platform version of the HANDOVER.md pattern I've been doing by hand since February — when the context fills up, distill it and continue. I'd still rather control what survives compaction myself for critical work, but for long-running background agents it removes a whole class of session death.

File-based memory got dramatically better. The launch material includes a number I keep coming back to: given access to file-based memory, Fable 5 showed a 3× performance improvement on complex long-horizon tasks. Not 30% — 3×. The model is meaningfully better at writing notes to itself and actually using them later. For those of us in the EU, this matters double: file-based memory remains the GDPR-compliant persistence path, while ChatGPT's full conversation recall is still geographically locked out. The architecture I can use from Sweden just became a lot more capable.

Mid-conversation system messages protect the cache. A smaller but telling addition: you can now inject operator instructions partway through a session as proper system-role messages appended to the conversation, instead of editing the top-level system prompt and invalidating the entire prompt cache. Caching economics shaped my whole platform comparison in March; this closes one of the more annoying gaps — changing an agent's instructions mid-flight no longer costs you the cached prefix.

Put together, the pattern is unmistakable. The new tier isn't "more context." It's a model that is aware of its budget, economical with its tokens, persistent through files, and steerable without cache destruction. Management, not capacity.

Sharper contracts, sharper separation of concerns

The second thing I find interesting about Fable 5 is how opinionated the API surface has become — and what that does for multi-agent work.

Fable 5 accepts adaptive thinking only. The old fixed thinking budgets are gone. temperature, top_p, and top_k are gone — send them and you get a 400. Even explicitly disabling thinking is now an error; you omit the parameter instead. Assistant-turn prefills, long the duct tape of output control, are rejected in favor of structured output schemas.

You can read this as Anthropic taking knobs away. I read it as interface contracts getting honest. Every removed parameter is a place where developers used to encode vague intent ("temperature 0.3 means... be a bit careful?") that the model interpreted unpredictably. What replaces them — effort levels, output schemas, task budgets — are contracts with defined semantics. In the separation-of-concerns post I argued that agent teams live or die on three things per agent: a clear mandate, a bounded context, and an interface contract. The platform is now enforcing the third one at the API level.

The multi-agent layer around the model has matured the same way. Anthropic's Managed Agents API — where Fable 5 slots in as a coordinator — runs delegation through context-isolated threads. Each subagent thread gets its own conversation history, its own system prompt, its own tools. Threads share the filesystem but not conversation context: if a coordinator wants a subagent to know something, it has to say so explicitly in the delegated message or write it to disk.

That constraint is the entire thesis of my agent teams series, enforced by infrastructure. There is no ambient knowledge. No tribal memory leaking between roles. The handoff is the contract, and anything not in the handoff doesn't exist. When I described Context as Code — externalizing shared knowledge into structured artifacts both humans and agents read — I was describing a discipline. The shared-filesystem-but-isolated-context model makes it the only way information moves at all.

Two more constraints in that design deserve attention, because they're governance decisions disguised as limits. Delegation goes one level deep — a coordinator's subagents cannot spawn their own subagents. And a coordinator's roster caps at 20 agents, with at most 25 threads running concurrently. Anyone who has watched an org chart grow middle management layers understands exactly what failure mode the one-level rule prevents: opaque hierarchies where accountability dissolves somewhere between the top and the work. My advice in March was a three-to-five agent squad with a thin orchestration layer above it. The platform's ceiling is more generous than my recommendation, but the shape — flat, bounded, explicitly rostered — is the same.

And the subagent threads are persistent. A coordinator can come back to a subagent it briefed earlier, and that subagent still has its prior turns. Specialists with memory of their own work, rather than stateless function calls. That's the difference between delegating to a colleague and shouting into a void.

The economics force a team structure

Fable 5 costs exactly double Opus 4.8, which costs more than Sonnet, which costs more than Haiku. For the first time there are four well-differentiated capability tiers in the same model family — and that pricing ladder is an org design argument.

I wrote about the cost model of agent teams in February: every agent in a pipeline adds token cost, and the cleanest decomposition is worthless if it's economically unviable. The four-tier ladder gives that trade-off real resolution. The coordinator — the role that needs long-horizon judgment, budget awareness, and the ability to recover from surprises — is where Fable 5's premium earns its keep. Discovery sweeps, mechanical transformations, validation passes against explicit rules: those are Sonnet and Haiku work, at a fifteenth or a thirtieth of the price.

This mirrors how you staff a human program. You don't put your most senior architect on data entry, and you don't put a junior on the steering committee. "Which model for which role" is now a genuine staffing decision with an order-of-magnitude cost range — and the answer falls directly out of the role definitions you should have written anyway.

What I'm actually doing

My subscription includes Fable 5 free until June 22, so the evaluation window is open and I intend to use it.

Claude Code sessions on my own projects move to Fable 5 now. The long-horizon claims are exactly the thing to test against real work: a four-hour session on the matbotten codebase, a multi-step infrastructure change across this server's stacks, the kind of task where Opus 4.8 is good but still occasionally loses the plot around hour three. If the file-based memory improvement is real at 3×, my .md-file workflow — CLAUDE.md, DECISIONS.md, HANDOVER.md — should get noticeably more leverage without me changing anything, because the model is better at the consuming end of those artifacts.

The agent-team experiments from the spring get re-run with a two-tier structure: Fable 5 coordinating, Sonnet 4.6 doing the specialist work. My hypothesis is that the coordinator tier is where the money matters and the specialist tiers are where it doesn't — which would mean the practical cost of upgrading a whole team is much less than the headline 2× suggests, since the coordinator emits a small fraction of total tokens.

After June 22, I decide what's worth $50 per million output tokens on an ongoing basis. My guess today: the orchestrator role and genuinely hard one-shot problems, nothing else. The pricing ladder exists to be used.

The deeper takeaway hasn't changed since March, but it's sharper now. The frontier isn't capacity — Fable 5 made the biggest capability jump in a year without adding a single token of context window. The frontier is management: models that know their budget, externalize their memory, respect their role boundaries, and hand off work through explicit contracts. Every one of those is a discipline practitioners have been building by hand. The platforms keep absorbing them, one by one, and the practitioners who understood the discipline first are the ones who'll get the most out of the infrastructure.