When Claude Fable 5 went offline on June 12, 2026 under U.S. export controls, your team did what every team did: repointed production at Claude Opus 4.8 or Sonnet 4.6, patched the prompts that broke, and shipped around the gap. The controls lifted on June 30, and Fable 5 is back as of July 1 across Claude.ai, the API, Claude Code, and Cowork. Anthropic confirmed the full redeployment in its official announcement.
The tempting move is to revert one commit and call it a day. Don’t. The service you’re returning to is not byte-for-byte the one you left; the safety layer was retrained during the outage, cloud platforms are still catching up, and the Opus 4.8 baseline you’ve been running for three weeks is now the most useful measuring stick you own. This runbook walks through the switch in order, with a regression pass in the middle, so you flip production back on evidence rather than muscle memory.
Inventory what changed while you were away
Three things moved between June 12 and July 1. One thing did not.
The safety classifier was retrained. The redeployed Fable 5 ships with a retrained safety classifier that targets a jailbreak technique reported during the outage window. Anthropic says it blocks more than 99% of attempts at that technique. Flagged requests don’t fail: they auto-reroute to Claude Opus 4.8, and the response carries a notification saying so. More than 95% of sessions never see a fallback. For a migration, the takeaway is narrow but important: your prompts now run against a slightly different safety layer than they did in early June. Retest instead of assuming.
Check your cloud platform’s status. Amazon Bedrock restored Fable 5 on July 1, the same day as the first-party API, though regional inference profiles can roll out unevenly. Google Vertex AI and Microsoft Foundry may still be catching up; Anthropic’s guidance for the platforms still pending is “as quickly as possible,” with no firm date. If your workload runs through a cloud provider, confirm Fable 5 is live on your platform and region before you schedule anything.
Subscription plans have a date to watch. If teammates use Claude on subscription plans rather than API keys, a plan-credit change takes effect July 7. It doesn’t touch API billing, but confirm how it affects any Claude Code or Cowork usage on those plans before you commit the team to a heavier Fable 5 workflow.
The model itself is unchanged. Same ID, claude-fable-5. Same 1M-token default context window, same 128K max output, same $10 per million input tokens and $50 per million output tokens. The models overview reflects the same entry it did in early June. Your request payloads from before the outage are still valid. What needs re-verification is behavior, not syntax.
Re-verify access with one minimal request
Before touching production config, send a single request from the environment that will serve traffic: same network path, same key, same SDK version. You’re confirming two things. Your credentials can reach the model, and the model that answers is the one you asked for.
A quick check from the terminal:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-fable-5",
"max_tokens": 256,
"messages": [{
"role": "user",
"content": "Summarize this changelog entry in one sentence: Added retry logic to the payments webhook."
}]
}'
And the same probe through the Python SDK, which is closer to what production runs:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-fable-5",
max_tokens=256,
messages=[{
"role": "user",
"content": "Summarize this changelog entry in one sentence: "
"Added retry logic to the payments webhook.",
}],
)
print(response.model) # expect "claude-fable-5"
print(response.stop_reason) # expect "end_turn"
print(response.usage) # token counts, for your cost model
The field that matters most is response.model. It names the model that served the request. If the new safety layer rerouted your call, this field reads claude-opus-4-8 instead, which is exactly the signal you’ll be monitoring after cutover. Checking it now, on one boring request, sets the habit.
Two failure modes are worth recognizing at this stage. A 404 on the model when you’re calling through Bedrock, Vertex AI, or Foundry usually means the cloud redeployment hasn’t reached your region yet; verify against the native API before filing a ticket. And a refusal stop reason on an obviously benign probe means your request shape is worth a closer look before you scale up, not after. If you’re wiring up a new service rather than restoring an old one, the full setup walkthrough is in how to use the Claude Fable 5 API.
Build a regression pass before re-pointing production
This is the step teams skip, and it’s the step that separates a clean Tuesday cutover from a Friday-night rollback. You’ve been serving traffic on Opus 4.8 since mid-June. That accident of history handed you something valuable: a live, measured baseline. Use it.
The goal is a suite of your real prompts, run against claude-fable-5, with results you can put next to the Opus 4.8 numbers. Here’s the workflow in Apidog:
1. Collect the prompts that pay your bills. Not synthetic tests. If you run an API-testing copilot, pull its top 50 production prompts: generate test cases from an OpenAPI spec, explain a failing assertion, draft a mock response for an endpoint. If you run a doc-summarization endpoint, sample real documents across your size range, from a two-paragraph release note to the 400-page PDF that stresses the context window.
2. Assemble them as a test scenario. In Apidog, each prompt becomes a request step against POST /v1/messages with model set to claude-fable-5. Environment variables hold the API key and base URL, so the same scenario runs against staging and production credentials without edits.
3. Assert on what production depends on. Four assertions cover most failure modes:
- Status is
200. - Latency sits under your SLO threshold. Fable 5 reasons before it answers, so set the bar from your pre-June measurements, not from Opus 4.8’s.
- The
modelfield in the response body equalsclaude-fable-5. This is the assertion that catches silent reroutes; a suite that passes on content but was served by Opus 4.8 tells you your prompts are tripping the new classifier. stop_reasonisend_turn, and the response fields your parsers read (the JSON shape from structured outputs, theusageblock your cost pipeline ingests) are present.
4. Run and compare. Execute the suite against claude-fable-5, then line the report up against the same suite’s Opus 4.8 run: pass rate, p95 latency, refusal count, output-shape failures. Differences here are cheap. The same differences discovered in production are not.
5. Gate the cutover in CI/CD. Apidog’s CLI runs the identical scenario in your pipeline, so the pull request that flips the model string only merges when the regression pass is green. That turns “we think it’s fine” into a build artifact.
Keep the suite running after cutover, too. Schedule it daily through the staged rollout, since a classifier-driven reroute that never appears in a 50-prompt run can still surface at production volume. The suite you built for the migration doubles as the canary that watches it.
Watch for reroutes to Opus 4.8
Here’s what a fallback looks like from the operator’s chair: the request succeeds, the completion is coherent, HTTP status is 200. But response.model reads claude-opus-4-8 and the response carries a notification that the request was rerouted. Nothing in your error handling fires, because nothing errored. Your latency profile, per-token cost, and output style shifted for that one call, silently, unless you’re logging the right fields.
Two fields per call is enough: the serving model and the usage block. Emit them into whatever observability stack you already run, and set an alert on the reroute rate. Since more than 95% of sessions see no fallback, a sustained spike above a few percent means something specific: a prompt template in your product resembles the pattern the retrained classifier targets. That’s a prompt-engineering ticket, not an incident, but only if you catch it in a dashboard instead of a customer email.
For requests you’d rather recover automatically, the fallbacks parameter (in beta on the Claude API and Claude Platform on AWS) retries or reroutes refusals inside the same call, without a second round trip from your code. It changes how you should structure retry logic, so it’s worth reading the dedicated guide to the Fable 5 fallbacks parameter before you build your own retry loop around refusals.
Re-run the cost math
For three weeks your bill has been priced at Opus 4.8 rates. Fable 5 costs about twice as much per token: $10 per million input and $50 per million output, unchanged from the pricing in the original launch announcement. Switching back is a deliberate spend increase, and finance will notice even if nobody else does.
Before the cutover, pull your Opus 4.8 usage for the fallback window and multiply it forward at Fable 5 rates. Then apply the caching discount, because that’s where the math gets interesting for agentic workloads. Prompt caching on Fable 5 carries a 90% discount, which prices cache hits at $1.00 per million tokens. An agent loop that resends a large, stable system prompt and tool definitions on every iteration can serve most of its input tokens from cache. A doc-summarization endpoint with a unique document per request cannot. Same model, same rate card, different effective cost per request.
Some teams will finish this arithmetic and conclude that part of their traffic should stay on Opus 4.8. That’s a legitimate outcome, not a failed migration. The capability side of that decision is covered in Fable 5 vs Opus 4.8; the short version is that you pay the premium for long-horizon reasoning, and routine completions rarely need it.
Cutover checklist
Run this top to bottom. Skipping ahead is how Friday deploys happen.
- Pin the model ID to
claude-fable-5in config, not in scattered string literals. - If you serve through Bedrock, Vertex AI, or Foundry, confirm Fable 5 is live on your platform and region before scheduling anything.
- Regression suite green in Apidog, with results compared against the Opus 4.8 baseline run.
- Stage the rollout: 5% of traffic, then 25%, then 100%, with at least one business day at each step.
- Log
response.modelandusageon every call from the first canary request onward. - Define the rollback trigger in writing before cutover: for example, reroute rate above 5%, p95 latency beyond SLO, or a parser error rate above baseline. Any single trigger reverts the traffic split.
- Alert on refusal and reroute rates, not only on HTTP errors. The failure mode here returns 200.
- Keep the Opus 4.8 path deployable. You built it under pressure in June; it’s your rollback plan now.
FAQ
Is the redeployed Fable 5 the same model that went offline in June? Same model ID, same specs, same pricing: claude-fable-5, 1M context, 128K max output, $10/$50 per million tokens. The difference is the retrained safety classifier sitting in front of it, which reroutes flagged requests to Opus 4.8. That’s why this guide insists on a regression pass instead of a straight revert.
What happens if one of my requests gets flagged? It doesn’t fail. The request auto-reroutes to Claude Opus 4.8, completes there, and the response includes a notification plus the serving model in the model field. More than 95% of sessions never encounter this. If your workload sees it often, review the prompts that trigger it and consider the beta fallbacks parameter for controlled handling.
Should I delete the failover code I wrote during the outage? No. The outage proved that single-model dependencies are fragile, and the routing layer you built is the durable win from an otherwise bad month. Keep it as your rollback path and formalize it; designing failover for AI APIs covers how to turn an emergency patch into architecture.
Wrapping up the switch
Moving back to Fable 5 is a migration, even though the model ID never changed. Treat it like one: verify access with a single request, run your real prompts as a regression suite against the retrained safety layer, compare the results with the Opus 4.8 baseline you’ve been accumulating since June, and roll out in stages with response.model on a dashboard. The teams that do this will be back on Fable 5 by the end of the week with numbers to prove it was safe. If you want the regression pass and the CI/CD gate in one tool, Download Apidog and build the scenario before you touch the config.
