Fable 5 is another step up the abstraction ladder on the long journey from “ai is better autocomplete”. We need to yet again throw out old assumptions about how to work with LLMs. Old prompt techniques that worked well before are now too constrictive. It’s a different animal entirely, and using it well means unlearning some habits.

Here I’ll describe how I’ve been using it, what works and what still doesn’t.

What it is

Fable 5 shipped on June 9, 2026 as Anthropic’s most capable widely released model, a tier that sits above Opus. Fable 5 and Mythos 5 share the same weights and capabilities. Mythos 5 is the model without safety classifiers, offered only to vetted partners through Project Glasswing. Fable 5 is that same model with the classifiers, generally available. Once you know that, a lot of Fable 5’s quirks make sense: you’re using a deliberately fenced-in frontier model.

Simon Willison, after a day of hands-on testing, was impressed: “the challenge is finding tasks that it can’t do.” The concrete demos would have blown us away a half year ago: a 50-million-line Ruby migration finished in a day, Pokémon FireRed beaten from raw screenshots with no helper harness. Those two are from Anthropic’s own announcement.

Stop writing playbooks

Every model before Fable 5 rewarded decomposition. You broke a task into steps, you handed the model a recipe, and it followed along more reliably than if you’d just stated the goal.

Fable 5 flips that, at least for open-ended work. Prescribe the reasoning path and you box in a model that reasons better than your recipe does. Constrain the outcome and the boundaries as hard as you like. But stop dictating the route. What it wants is an outcome description:

  1. The larger project, and who it’s for
  2. What the finished outcome enables
  3. The current state, and the relevant files
  4. The non-negotiable constraints
  5. The goal

Then get out of the way. Anthropic’s own prompting guide recommends a system-prompt line that gives it explicit permission to move, to stop it overplanning on ambiguous tasks:

When you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue in user-facing messages. If you are weighing a choice, give a recommendation, not an exhaustive survey.

Like previous models though, high-effort Fable 5 tends to over-verify, producing polished work that costs more than it needed to. It helps to tell it not to add features, refactor, or abstract beyond what the task requires. The YAGNI principle has been a mainstay in my main CLAUDE.md for almost a year and remains relevant with Fable.

What “long-horizon” really means

Anthropic says Fable is capable of performing “days-long, complex, asynchronous tasks.” In plain terms: give it an agent harness with file-based memory and Fable 5 will run, verify its own work, revise, and hold a coherent thread for hours. That memory isn’t the model, it’s the harness handing it files and telling it to keep notes. A stateless API doesn’t remember anything between calls. What’s new is that Fable 5 uses that scaffolding well. It is much better at deciding what should be recorded, organizing those notes, retrieving them later, and using them without losing sight of the overall goal.

Two behaviors I’ve watched it do that older models didn’t:

  • It’s hypothesis-driven. It doesn’t just try fixes until one sticks; it forms a hypothesis, runs something to test it, and revises. If the evidence disagrees, it revises the hypothesis rather than continuing blindly. Reasoning becomes more reliable when it can test beliefs against reality. That’s why it’s strong in an environment where it can execute and observe, and weaker as a one-shot oracle.
  • It runs, then fixes. That same experimental approach can be a double-edged sword. Hand it a subtly wrong command and it tends to execute first and correct after. Something to think about before you give it a production shell.

How I actually use it

Most of my Fable 5 time isn’t spent watching it write code. Instead, I run it as a coordinator. My current pattern: I hand it a goal (port a feature from one of my products to another, bring one agent box up to parity with another), it searches my notes and past sessions for context, and then it writes the plan out as a document I can actually read and approve before a line of code exists. Once I sign off, it dispatches a fleet of subagents (Opus, or increasingly GPT-5.6) to implement in parallel, and reviews what they hand back before it comes back to me. I wrote the rule into my CLAUDE.md: Fable plans and reviews, the cheaper/faster models write.

A Claude Code session used to be a firehose. You sat and watched a wall of code scroll past, because the one agent doing the work was also the only thing you could talk to, so watching it was the job. With Fable coordinating, the implementation runs in the background across a fleet of subagents and the main agent stays free. I can see where the session is at a high level instead of reading every line, and when I think of the next thing that needs doing, I tell the main agent and it gets queued. Nothing blocks on a wall of output finishing. It’s the difference between reading over one engineer’s shoulder and checking in with a lead whose team is heads-down.

Here’s what’s currently in my CLAUDE.md for how Fable is to be used:

## Fable 5: Coordinator Role
When the session model is Fable 5 (`claude-fable-5`):
- **Fable coordinates, Opus codes.** Act as project manager: plan, decompose, dispatch, review, verify. Delegate implementation work to Opus subagents (`Agent` tool with `model: "opus"`). Spend Fable tokens on planning, hard reasoning, and cross-cutting review — not routine edits ($50/M output vs Opus).
- Exceptions: trivial edits (a few lines) and tight debug loops where handoff overhead exceeds the work — do those directly.
- When writing prompts for Fable (subagents, scheduled runs): use outcome-description format — larger context, current state, constraints, goal. Step-by-step playbooks written for Opus DEGRADE Fable output.

The guardrails

Fable 5 ships under Anthropic’s ASL-3 safeguards and its classifiers watch three specific domains: offensive cybersecurity, biology and chemistry, and extraction of the model’s own reasoning (to stop rivals training on it). If your work is ordinary coding, product, and writing, the safety layer is close to invisible for you.

Anthropic’s prompting guide warns that “benign cybersecurity work and beneficial life sciences tasks may also trigger these safeguards.” If that’s you, don’t fight the classifier, route that work to Sonnet 5 or Opus directly.

A raw API refusal arrives as HTTP 200 with stop_reason: "refusal" and a stop_details.category. Automatic API retry requires server-side fallback, SDK middleware, or application logic.

Claude Code handles this automatically by default, but visibly: it shows a switch notice, labels the answer as Opus 4.8, and leaves the conversation on Opus until you switch back.

For science, I deliberately triggered the classifier to see what would happen:

Fable 5’s bio classifier refusing a request in Claude Code and switching to Opus 4.8

In my daily work, I have not yet hit a fallback to Opus.

Prompts or skills that tell the model to echo or explain its own reasoning as output can trip the reasoning-extraction classifier. If you carried “show your thinking” instructions over from an Opus-era setup, audit them out.

Two more operational facts that will surprise you:

  • Mandatory 30-day retention. There is no zero-retention option. If your org enforces ZDR, your calls fail with invalid_request_error until the config is loosened. For regulated workloads, this alone can make Opus 4.8 the right choice.
  • Thinking is always on and never shown. You can’t disable adaptive thinking; the effort parameter (low through max) is your cost lever. And you never get raw chain-of-thought back, only a summary or nothing.

What it costs, and when it’s worth it

Fable is a premium model that comes at a premium price. The sticker price is $10 / $50 per million tokens, double Opus 4.8’s rate and the most Anthropic has ever charged for a general model. But per-token price undersells it, because Fable also thinks more per task (adaptive thinking is always on) and over-verifies at high effort. Artificial Analysis captures the real number with cost-per-task: the total spend to run their full Intelligence Index suite.

Fable 5 with fallback runs $2.75 a task. “Task” here is defined by Artificial Analysis’s specific Intelligence Index workload, weighted across its benchmark categories. GPT-5.6 Sol at max effort is $1.04. Kimi K3 is about $0.95. For that roughly 3x premium, Fable scores 60 on their intelligence index, against Sol’s 59 and Kimi’s 57. You are paying triple for the top of a very tight pack.

Cost per task to run Artificial Analysis’s Intelligence Index; Fable 5 is the most expensive by far Cost per task to run Artificial Analysis’s Intelligence Index, lower is better. Source: Artificial Analysis.

That chart is the argument for using Fable as a coordinator instead of an implementer. Let it plan and review while cheaper models write, and you spend the $2.75-a-task intelligence on the fraction of the work that actually needs judgment, and let a Sol or a Kimi K3 burn the tokens on the boilerplate. Pay Fable rates to write a CRUD endpoint and you are lighting money on fire for output a model a third the price gets right.

Unless your employer is AI pilled enough to pay API rates for Fable, or you have investor money to burn, most of us will be accessing Fable via Claude Code. Anthropic first tried to pull Fable from plans and reserve it for API pricing, extended the cutoff three times as users revolted, and then made it permanent instead. From July 20, Fable is included in Max and Team Premium plans at 50% of your weekly limits, with each Fable token burning that limit at roughly twice the rate of an Opus token. Pro and Team Standard users don’t get it bundled, so they pay through usage credits at the $10/$50 API rate, somewhat softened by a one-time $100 credit. The reason for that split is the chart above. With Sol and Kimi K3 landing near a third of Fable’s per-task cost, hiding Fable behind an API-only paywall stopped being tenable.

Three ways to mitigate cost on Fable 5:

  • Keep the cache warm. In Claude Code caching is automatic; on a subscription it even uses the one-hour cache for free. What you control is not breaking it: switching model, changing effort, or running /compact each force the next turn to re-read your whole context at full price, when reads are otherwise 90% off. Pick model and effort at the start of a session and save /compact for the breaks between tasks. Manual cache_control breakpoints only matter if you’re building your own agent on the API.
  • Tune effort deliberately. Anthropic recommends high as the default, xhigh for the hardest work, and medium or low for routine tasks. Fable 5 at low effort often beats prior models at their max. So drop the effort when a task completes but runs longer than it should, rather than reaching for high reflexively.
  • Mix models. Use Sonnet 5 to gather context, hand only the hard reasoning to Fable 5. And watch your fallback rate: if a domain keeps bouncing to Opus, you’re paying the Fable premium for Opus output, so route it straight to Opus.

What it’s still bad at

For all the capability, Fable 5 still has many of the same weaknesses as previous LLMs. In some cases it has gotten worse.

It states guesses as facts. The system card shows a real regression in missing-context hallucination. When a reference or tool it expects isn’t there, Fable 5 invents one about 18% of the time, against 9% for Opus 4.8. It’s less willing to say “I don’t know” and more willing to assert something plausible it never verified. In a chat you’re watching, you’ll (maybe) catch it. In an agent running unattended for an hour, a confident fabrication three steps back can poison everything downstream. So make it show receipts: tie claims to a file or a command output.

It agrees with you too easily. AKA sycophancy. Push back on something Fable 5 said, even when you’re the one who’s wrong, and it tends to fold. Depending on the test, it either regresses to the sycophancy of much older models or ranks best in class. The model is a little more eager to tell you you’re right than to hold a correct position. The fix is to stop handing it the answer you want. Ask “what’s wrong with this approach” instead of “this is good, right?”. Confirmation bias is yet again the enemy.

Its design taste is generic. Ask for a landing page and you get the output everyone else gets: system fonts, a purple gradient, a big-number hero, cards in a grid. Anthropic clearly knows: it ships an official Frontend Design plugin whose whole job is to steer Claude away from “generic system fonts, predictable purple gradients, and cookie-cutter components.” That’s an admission that the default has a taste problem. Not that the model can’t design, it tops the UI benchmarks. But the plugin only helps if the task reads as design work and you’ve handed it a real brief: a subject, an audience, a point of view. Generic in, generic out. The plugin is just a good prompt you can install, and “prompt it very well” is the entire game.

Its prose still reads like an AI wrote it. Out of the box the writing is competent and characterless, the exact register that makes people say “this sounds like Claude.” There’s even a word for it now: claudish. This seems nearly impossible to prompt your way out of. Some say GPT-5.6 is more steerable away from this sort of generic AI writing style.

Takeaway

Fable 5 is the strongest model I’ve used and the one that most punishes using it like the last one. Used correctly, it unlocks the next step in the abstraction ladder: a true product owner, not a junior engineer. It is also the most expensive, and has the most guardrails on what you can use it for.

Reach for Fable 5 when the cost of babysitting a cheaper model, the re-prompts, the missed context, the mistakes you’d have to catch, is higher than the premium. When a task is easy to specify and easy to verify, a cheaper model wins and Fable is just an expensive way to get the same answer. When it’s ambiguous, long, or needs one capable agent holding the whole thread, that’s the premium earning out. Describe the outcome, verify the dangerous defaults, and point it at the work that’s actually hard. Use it like last year’s model and you’ll pay frontier prices for frontier frustration.