Claude Fable 5: The Model That Thinks So Hard You Can't Turn It Off

Claude Fable 5 has three features that sound like bugs. You can't turn off its thinking. It costs more than Opus. And it slices the same text into about 30% more tokens than you're used to. All three are on purpose, and once you see why, the model makes a lot more sense.

So here's the tour: what Fable 5 actually is, the facts that'll trip you up the first time, what genuinely got better, and the part nobody puts in the launch post: when you should not reach for it.

What it even is

Fable 5 is Anthropic's most capable widely released model, and it's built for the hard end of the work. Overnight agent runs. First-shot builds of a system you've specified well. The kind of debugging that used to need a human babysitting the loop. It carries a 1M token context window (that's the default, not just a ceiling you can opt into) and can write up to 128K tokens back.

The part most people get wrong on day one: it's not a drop-in upgrade for everything. If your whole ask is "give me the latest and greatest," the sensible move is Opus 4.8. Fable 5 is the model you reach for on purpose, for the jobs that were genuinely out of reach before. Think of it as the specialist you call in, not the one who sits at the front desk.

The facts that'll trip you up first

This is the fun part, because every one of these has quietly broken someone's afternoon.

Thinking is always on. On older models you flipped thinking on, set a token budget, or switched it off. On Fable 5 you do none of that. The reasoning is always running, and trying to disable it is a flat 400. The old budget_tokens knob is gone too. What you get instead is one dial: effort.

import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();

// Thinking is always on. You don't request it, and you can't turn it off.
// Steer how deep it goes with effort, not a token budget.
const res = await client.messages.create({
  model: "claude-fable-5",
  max_tokens: 16000,
  output_config: { effort: "high" }, // low | medium | high | xhigh | max
  messages: [{ role: "user", content: "..." }],
});
// Sending thinking: { type: "disabled" } here? That's a 400.

You never see the raw reasoning. Fable 5 thinks in full behind the scenes and hands you a summary, or nothing at all. The unfiltered chain of thought is sealed and never returned. Ask for the summarized view if you want the gist; otherwise the thinking field comes back empty while the model still thought (and still billed) for the work. One sharp edge: if you're continuing a conversation on the same model, pass those thinking blocks back exactly as you got them. Edit them and the API rejects the turn. Hand them to a different model and they're quietly dropped, no charge, no error.

The token math you memorized is wrong now. Fable 5 ships a new tokenizer. The paragraph that was 1,000 tokens on Opus lands closer to 1,300 here. Nothing you wrote changed; the ruler did. So every max_tokens you hand-tuned, every cost estimate sitting in a spreadsheet, every "this fits in the window" assumption needs a fresh measurement. Run count_tokens with model: "claude-fable-5" and it'll hand you the count under both tokenizers, so you can see the gap before it shows up on the invoice.

A refusal is a 200, not a crash. This one gets everybody once. Fable 5 runs safety classifiers on the way in, mostly around biology and cybersecurity, and benign-adjacent work can trip them too. When one declines, you don't get an exception. You get a cheerful HTTP 200 with stop_reason set to "refusal" and, often, an empty content array. Code that grabs content[0] without looking will throw on thin air.

const res = await client.beta.messages.create({
  model: "claude-fable-5",
  max_tokens: 16000,
  betas: ["server-side-fallback-2026-06-01"],
  fallbacks: [{ model: "claude-opus-4-8" }], // refusals retry here, same request
  messages: [{ role: "user", content: "..." }],
});

// Check stop_reason BEFORE you read content.
if (res.stop_reason === "refusal") {
  // a classifier declined; content is empty (pre-output) or partial (mid-stream)
}

The nice part: wire up that fallback and a refusal quietly retries on Opus 4.8 in the same round trip, and you only pay for the answer that actually comes back.

It wants your data for 30 days. Fable 5 isn't available under zero data retention. If your org is set to ZDR, every request 400s no matter how clean the payload is. Worth knowing before you burn an afternoon debugging a request that was fine all along.

A single call can run for minutes. On a genuinely hard task at high effort, one request can chew for several minutes. A fifteen-minute call isn't a hang; it's the model gathering context, building, and checking its own work. Plan for it. Stream the response, show progress, and let people wander off and come back instead of staring at a spinner that looks frozen.

What actually got better

The headline is long-horizon work. Fable 5 is built to run far without a hand on its shoulder: big refactors, multi-step builds, the overnight kind of task. The trick to getting the most out of it is boring but real. Give it the whole spec up front in one clear turn, set effort high, and let it go. It plans more before it acts, and that front-loaded thinking usually means fewer wrong turns, not more.

The surprising win is at the cheap end of the dial.

You'd expect a premium model to shine at max effort, and it does. But the bigger story is that Fable 5 at low or medium often beats older models running flat out. So "worth the premium" doesn't have to mean "crank everything to max and eat the bill." A lot of work runs fine on a low setting and still comes out ahead.

Debugging got noticeably sharper. It finds real bugs instead of plausible-looking ones, and it's better at the worst kind: the intermittent flake, where weaker models run the test once, see green, and declare victory. (Fair warning, that bug-finding strength doesn't stretch into security analysis, where those same classifiers tend to step in.)

It's a better delegator, too. Where older models would spawn a sub-agent and then sit there blocked until it finished, Fable 5 keeps long-running sub-agents alive and talks to them while it works on something else. If your harness fans work out across agents, that changes how much you can keep in flight at once.

It can also read a bad photo. Flipped, blurry, low-light, noisy. It's trained to reach for crop and zoom tools instead of squinting and guessing, which helps a lot on the screenshot-and-document side of vision.

And here's the twist that catches careful prompt engineers off guard: your hard-won scaffolding can hurt. All those "FIRST do X, THEN do Y, ALWAYS verify Z" prompts you tuned for older models tend to over-constrain Fable 5 and drag its output quality down. The better move is to state the goal and the constraints, then get out of the way. Years of prompt-wrangling instinct, and the new advice is mostly "say less."

The catch

None of this is free, and I mean that literally. Fable 5 runs $10 per million input tokens and $50 per million output, against Opus 4.8's $5 and $25. Stack the higher rate on top of a tokenizer that counts more tokens for the same text, and an unchanged workload can cost a good bit more than your gut expects. It can also refuse work that's perfectly legitimate but happens to sit near a sensitive area. And it won't run at all under zero retention.

This is a specialist. For everyday traffic, Opus 4.8 is still the one to reach for. Fable 5 earns its keep on the problems that were actually out of reach before, not the ones you've already solved twice.

(One footnote for completeness: if you're in Anthropic's Project Glasswing, you'll meet the same model wearing the name Claude Mythos 5. Same capabilities, same price, different label.)

So when do you actually use it

Hand it the problem you haven't been able to crack. Give it the full picture in one go, not a trickle of follow-ups. Set the effort to match how much the answer matters, wire a fallback for the occasional refusal, and let it run while you go do something else.

Just don't ask it to stop thinking. That's the one thing it won't do for you.