Claude Fable 5 Is Back: Export Controls Lifted and Global Access Restored July 1

TL;DR — Anthropic's most capable widely released model, Claude Fable 5 (claude-fable-5), is available again. It shipped June 9, 2026, got pulled behind US export controls on June 12 after a jailbreak bypass surfaced, and — with those controls lifted on June 30 — came back online globally on July 1. Fable 5 is a Mythos-class model with safety classifiers bolted on; the redeploy adds a new classifier that neutralizes the reported bypass with over 99% effectiveness. If you integrate against it, you now have to handle refusals, wire up fallback, and understand the new billing rules. Here's the developer breakdown.

What Just Happened: The 3-Week Timeline

Fable 5's launch-to-relaunch arc is one of the fastest regulatory round-trips a frontier model has been through. The dates matter, so here they are in order:

The short version: a bypass technique defeated Fable 5's safety classifiers, the government treated the uncontrolled capability as export-sensitive, Anthropic patched the classifier and demonstrated the fix, and access was restored in under three weeks. This is the first time a public Claude model has been gated and un-gated by export policy — and it is a preview of how frontier releases will be governed going forward.

What Claude Fable 5 Actually Is

Fable 5 is Anthropic's most capable widely released model — built for demanding reasoning and long-horizon agentic work, state-of-the-art on nearly every capability benchmark Anthropic tested, and able to work autonomously for longer than any prior public Claude model. It is the general-availability sibling of Claude Mythos 5, the model I wrote about in the Mythos & Project Glasswing piece.

The two share the same underlying architecture and the same specs. The difference is one thing: classifiers.

Fable 5 is what you call from production. Mythos 5 is the un-classified frontier system reserved for vetted defensive-security partners. If you don't have Glasswing access, Fable 5 gives you the same raw capability with guardrails in front of it.

The Fix: A 99%+ Bypass Classifier and a Wider Safety Margin

The reason Fable 5 came back at all is that Anthropic closed the hole that got it pulled. The redeploy uses a defense-in-depth stack whose most important layer is a new safety classifier — a smaller automated model that detects when Fable 5 is being asked to perform a potentially harmful cybersecurity task.

Two specifics worth internalizing:

1. 01The new classifier neutralizes the reported bypass with over 99% effectiveness. That number is what satisfied regulators enough to lift the controls.
2. 02Anthropic deliberately widened the safety margin. The classifier is tuned to block some benign requests rather than risk letting harmful ones through. In other words, Fable 5 will occasionally refuse something legitimate. That is a design choice, not a bug — and it's exactly why your integration needs a refusal path.

Anthropic also published a jailbreak severity framework that scores a bypass across four axes — capability gain, breadth of that gain, ease of weaponization, and discoverability — ranging from minor to universal. Expect this to become the shared vocabulary the industry uses to triage model jailbreaks.

What Changes for Developers: Refusals, Fallback, Billing

This is the part that actually touches your code. Because Fable 5 can decline requests, three things are different from calling Opus 4.8 or any earlier model. Plan for all three.

1. Refusals are a successful response, not an error

When Fable 5 declines, the Messages API returns stop_reason: "refusal" as an HTTP 200 — not a 4xx/5xx. The response also tells you which classifier declined. If your client treats non-200 as the only failure mode, you'll silently mishandle refusals.

const res = await anthropic.messages.create({
  model: "claude-fable-5",
  max_tokens: 8192,
  messages: [{ role: "user", content: prompt }],
});

// A refusal is a 200 — branch on stop_reason, not on HTTP status
if (res.stop_reason === "refusal") {
  // res tells you which classifier declined; retry on a fallback model
  return retryOnFallbackModel(prompt);
}

2. Fallback: retry a refused request on another model

A request Fable 5 refuses can usually be served by another Claude model. There are three ways to wire this up:

• Server-side — pass the fallbacks parameter and let the API retry for you (in beta on the Claude API and on AWS).
• Client-side — use the official SDK middleware (TypeScript, Python, Go, Java, C#) to retry from any platform.
• Manual — build the retry yourself, anywhere, in any language.

// Server-side fallback (beta): API retries on the listed model if Fable 5 refuses
const res = await anthropic.messages.create({
  model: "claude-fable-5",
  max_tokens: 8192,
  messages: [{ role: "user", content: prompt }],
  // @ts-expect-error beta parameter
  fallbacks: ["claude-opus-4-8"],
});

3. Billing: you don't pay for a refusal, and switching is subsidized

Two rules that protect your bill:

• You are not billed for a request refused before any output is generated. A pure refusal is free.
• On retry, "fallback credit" refunds the prompt-cache cost of switching models, so you don't pay the cache warm-up twice.

Net effect: a well-instrumented Fable 5 integration costs about the same as before even with refusals in the mix — if you use the fallback path instead of hand-rolling retries that re-pay cache costs.

API Behavior You Should Know

Beyond refusals, Fable 5 (and Mythos 5) change a few Messages API defaults relative to Opus/Sonnet/Haiku:

• Adaptive thinking is always on. It's the only thinking mode. thinking: {"type": "disabled"} is not supported — use the effort parameter to control reasoning depth and cost.
• Raw chain-of-thought is never returned. thinking.display is either "summarized" (readable summary) or "omitted" (empty, the default). Pass thinking blocks back unchanged within a same-model conversation.
• Data retention is 30 days, and both models are Covered Models — zero-data-retention is not available. Factor this into regulated workloads.

Supported at launch: effort, task budgets (beta), the memory tool, code execution, programmatic tool calling, context editing (beta), compaction, and vision.

Pricing and the Free-Trial Window

Fable 5 and Mythos 5 are both $10 per million input tokens and $50 per million output tokens — the same tier Anthropic uses for Fast Mode on Opus 4.8 (which I covered in the Opus 4.8 release breakdown).

For the relaunch, paid plans get a runway:

• Pro, Max, Team, and Enterprise plans receive a 50% weekly usage allocation for Fable 5 through July 7, 2026.
• After July 7, continued Fable 5 use runs on usage credits.

If you want to evaluate Fable 5 against your Opus 4.8 workloads, the window to do it cheaply closes July 7 — run your evals this week.

Where You Can Call It

Fable 5 is generally available across:

• Claude API and Claude Platform on AWS
• Amazon Bedrock, Google Cloud (Vertex AI), and Microsoft Foundry
• claude.ai, Claude Code, and Claude Cowork

Mythos 5 remains limited to approved Project Glasswing customers; everyone else uses Fable 5, which offers the same capabilities with the classifiers in place.

Migration: Opus 4.8 → Fable 5

If you're on claude-opus-4-8 and want the capability jump, the migration is mostly a model-string swap plus the refusal/fallback handling above.

// Before
const response = await anthropic.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 8192,
  messages: [{ role: "user", content: prompt }],
});

// After — more capable, but now handle refusals + fallback
const response = await anthropic.messages.create({
  model: "claude-fable-5",
  max_tokens: 8192,
  messages: [{ role: "user", content: prompt }],
  // control reasoning depth/cost — thinking can't be disabled
  // @ts-expect-error beta parameters
  effort: "high",
  fallbacks: ["claude-opus-4-8"],
});

Do not ship the swap without a refusal branch. The single most common Fable 5 integration bug will be code that assumes every 200 response contains usable content — then breaks the first time a legitimate request trips the widened safety margin.

Why This Matters Beyond the Changelog

The Fable 5 saga is the first real-world instance of frontier-model access being governed by export policy in near-real-time. A capability shipped, a bypass made it export-sensitive, a classifier fix un-gated it — all inside three weeks. That's the governance loop every serious AI lab and every downstream developer now operates inside.

Two takeaways for anyone building on frontier models:

1. 01Availability is now a moving target. Build fallback into your architecture as a first-class concern, not an afterthought. The fallbacks parameter exists precisely because "the best model might refuse, or might briefly be unavailable" is now a normal operating condition.
2. 02Safety margins have a product cost you inherit. When a lab widens its classifier to satisfy regulators, your users feel the false positives. Handling refusals gracefully — with a transparent fallback — is part of shipping on frontier models in 2026.

Bottom Line

Claude Fable 5 is back, globally, as of July 1, 2026, with a classifier that closes the bypass that got it pulled. It is the most capable model you can call from production today — same 1M context, same $10/$50 pricing as the Fast tier, and Mythos-class capability with guardrails. The cost of admission is three code changes: branch on stop_reason: "refusal", wire up fallbacks, and lean on fallback credit for billing. Do those, run your evals before the July 7 free-allocation cutoff, and you're on the frontier — without betting your uptime on a single model that can say no.

Harsh Rastogi is an AI Product Engineer at Modelia, building production Generative AI systems. He writes about AI systems, developer tooling, and production engineering at harshrastogi.tech.