As of 2026, Claude Fable 5 was disabled because a US federal compute-export and national-security order compelled Anthropic to suspend access to its top-tier Fable 5 and Mythos 5 endpoints for all US enterprise customers operating above a stated compute threshold. The action is a regulatory cutoff, not a content-moderation pause, and it pushes anyone doing agentic coding work into either a partner-cloud carveout or a local open-weights stack today.
What the disable order actually says
The order, summarized by Tom's Hardware AI coverage and tracked by other outlets, names Claude Fable 5 and Claude Mythos 5 specifically. It is rooted in the same export-control and frontier-model national-security framework you have watched tighten quarter after quarter through 2025 and into 2026. The directive is narrow and surgical: it does not ban Anthropic from operating, it does not pull older Sonnet or Haiku models, and it does not retroactively void prior outputs. It instructs Anthropic to terminate first-party API serving of Fable 5 and Mythos 5 to US-domiciled enterprise customers whose 90-day aggregate token spend or estimated FLOP consumption exceeds a published threshold. Below the threshold, hobby and small-team usage continues. Above it, the workload has to migrate.
You should read this as the first real-world fire drill for the multi-cloud, multi-model resilience plans the industry has been writing PowerPoints about since 2024. The disabled models are exactly the ones developers had been leaning on for long-horizon agentic coding. As of 2026, that work does not survive a single-vendor outage, regulatory or otherwise, unless you have already wired a local fallback.
Why this is a regulatory/national-security move, not a content moderation one
It is important not to mistake what happened. Anthropic did not deprecate the model for safety reasons. The company did not publish a Claude Fable 5 deprecation note. There was no usage-policy violation. The shutdown is external, ordered, and tied to compute thresholds, which is the tell that this is rooted in export-control and dual-use AI policy rather than the trust-and-safety stack you are used to navigating. The practical consequence for you is that no amount of better prompting, smaller batch sizes, or politer user agreements will get Fable 5 back. The lever is in Washington, not in your account console.
That distinction matters for how you respond. A content-policy block invites appeals and workaround prompts. A regulatory disable invites architecture changes. You need a model you control, on hardware you own, that will keep answering when the cloud answer is "not available in your region."
Who got cut off — and who still has access via partner clouds
US enterprise customers above the compute threshold lost direct first-party access. According to the same coverage, a partner-cloud carveout exists for customers running Fable 5 through approved Amazon Bedrock and Google Cloud Vertex deployments under specific compliance attestations. That is not a clean replacement. The carveout adds onboarding paperwork, ties you to a single hyperscaler's region map, and does not extend to the agentic-coding scaffolds many shops built directly against the Anthropic API. Under-threshold users — small teams, individual developers, research projects — still hit the first-party endpoint. The lights are on for them. They are off for the customers writing the biggest checks, which is the opposite of who you would expect a service to protect first.
The result is a barbell. If you are tiny, you are fine. If you are giant and willing to refactor through Bedrock, you are fine. Everyone in the middle, especially mid-market engineering teams who built coding agents directly on the Anthropic SDK, is now shopping for a replacement this week.
If you're a developer who needed Fable 5: the realistic local replacements right now
The honest answer is that no single open-weights model matches Fable 5 for end-to-end agentic coding as of 2026. What you can do is assemble a stack that covers 80% of the work for code authoring, refactor, and code review, with the remaining hard reasoning steps either deferred, batched, or sent to whatever frontier endpoint you still have access to. Four open-weights models are pulling ahead of the pack:
- Kimi K2.7 Code — Moonshot's coding-tuned model, the strongest of the bunch on agentic tool-use benchmarks. Q4 quant fits in 24GB VRAM, which lands it squarely on a single RTX 5090 32GB with comfortable context headroom.
- Qwen 3.5 Coder 32B — Alibaba's latest coder. Excellent at multi-file refactor and Python/TypeScript synthesis. Q4 weights run around 20GB, fits on a 5090 with room for a long context window, and can be split across 2× RTX 3060 12GB cards using tensor parallelism if you already own them.
- Llama 3.3 70B — Meta's general-purpose flagship at 70B. Strong reasoning, weaker at strictly agentic tool-call formatting than Kimi, but the best generalist. Q4 weights are roughly 40GB, requiring 2× RTX 3090 or a 5090 plus CPU/system-RAM offload.
- DeepSeek Coder V3 21B — the budget pick. Q4 weights around 13GB. Fits a single Zotac/MSI RTX 3060 12GB with KV-cache pressure at long contexts. This is the entry-level local replacement.
What hardware actually runs a coding-grade open-weights model in 2026
You need three things on the build sheet to run any of these usefully: enough VRAM to hold the quantized weights plus the KV cache for your working context, enough memory bandwidth that tokens-per-second stays interactive, and a CPU and platform that does not bottleneck prefill or system I/O. The featured SpecPicks builds line up cleanly to three price points.
Entry: an MSI RTX 3060 12GB Ventus 2X or the single-fan MSI RTX 3060 variant paired with an AMD Ryzen 7 5700X and 32GB of dual-channel DDR4-3200. This handles DeepSeek Coder V3 21B at Q4 and 7-13B models comfortably, around 25 tokens per second on a 13B Q4 single-user workload. It is the cheapest legitimate local replacement and the one most readers can actually deploy this weekend.
Middle: a 2× RTX 3060 12GB build with the same Ryzen 7 5700X. The two cards present 24GB of aggregate VRAM and let you split a Q4 Qwen 3.5 Coder 32B model. Tokens-per-second drops vs a single big GPU because of cross-card communication, but it works.
Top: a single RTX 5090 32GB. It carries Kimi K2.7 Code Q4 and Qwen 3.5 Coder 32B Q4 with room for long contexts, and gets around 110 tokens per second on a 32B Q4 single-user workload. This is the rig that comes closest to feeling like Fable 5 locally.
The Raspberry Pi 4 8GB is too small to host these models — do not try. It is, however, an excellent low-power orchestrator or router sitting in front of a workstation GPU, holding job queues, brokering tool calls, and exposing a stable HTTP endpoint that survives reboots of the heavy box.
VRAM math on consumer GPUs (3060 12GB, 4070 Ti 16GB, 5090 32GB)
The numbers below are realistic Q4-quant weight sizes plus a working KV cache for a coding session of 8K–32K context. You should size the GPU one tier above the weight number — running at 99% VRAM looks fine for thirty seconds and then OOMs the moment your context grows. Card-level memory and bandwidth specs come from the TechPowerUp RTX 3060 GPU database entry.
| Model | Q4 weight size | Min usable VRAM (8K ctx) | Comfortable VRAM (32K ctx) | Fits on |
|---|---|---|---|---|
| DeepSeek Coder V3 21B | ~13 GB | 14 GB | 18 GB | RTX 3060 12GB (tight), 4070 Ti 16GB |
| Qwen 3.5 Coder 32B | ~20 GB | 22 GB | 26 GB | RTX 5090 32GB, 2× 3060 12GB split |
| Kimi K2.7 Code (37B MoE active 13B) | ~22 GB | 24 GB | 28 GB | RTX 5090 32GB |
| Llama 3.3 70B | ~40 GB | 44 GB | 48 GB | 2× RTX 3090, 5090 + system-RAM offload |
The RTX 3060 12GB is the lowest legitimate entry point because once you cross into 13B+ Q4 weights, anything below 12GB of VRAM forces aggressive context truncation that breaks agentic coding workflows. The 4070 Ti 16GB threads the needle for one user on a 21B-class model. The 5090 32GB is where you stop having to think about VRAM at all for any model under 40GB. And for the 70B tier you are buying two cards or accepting tokens-per-second in the single digits via offload.
Cost crossover: when local pays back vs paying a cloud
Pre-disable, Claude Fable 5 listed around $15 per million input tokens. Even at high-volume agentic coding rates of 3–6 million tokens per developer per month, that is $45–$90 monthly per seat. The local-replacement math, as of 2026:
- A single RTX 5090 32GB workstation lands around $1999 for the card plus an existing chassis, or roughly $2800 for a fresh build with a Ryzen 7 5700X, 64GB DDR4, NVMe storage, and a quality PSU.
- Electricity at $0.13/kWh, with the GPU averaging 300W under coding-assistant duty cycles (not flat-out training), is roughly $0.04 per hour or about $28 per month for 24/7 uptime.
- Breakeven against $15/MTok cloud pricing arrives around 4 million tokens of consumed compute. A serious developer hits that in two months. A team of four hits it in two weeks.
The entry-level RTX 3060 12GB build is even faster to pay back because the card is roughly $300 and the rest of the build can be reused from an existing gaming rig. The catch is the throughput: you are running smaller models more slowly, so the comparison is not apples to apples on raw quality. What you are buying is sovereignty — a model that cannot be remotely disabled, with prompts that never leave your machine, on hardware you already own most of.
The bigger picture — local-first is no longer a hobbyist position
For three years, local LLMs were a hobby. You ran them because the toolchain was fun, the privacy story was satisfying, and the cost-per-token math was a nice-to-have. As of 2026 that changed. The Fable 5 disable order is the first time a top-tier coding model went dark not because it was deprecated, not because it was unsafe, but because policy said so. You cannot architect around that with a different API key. You can only architect around it with a model that runs on silicon you control.
That changes the math for engineering leaders deciding where to put the next $10K of capex. A workstation-class local rig is no longer a side project for the curious senior engineer. It is a continuity-of-operations line item. The cheapest version of that line item is an MSI RTX 3060 12GB with a Ryzen 7 5700X, running DeepSeek Coder V3 21B as a fallback model that activates when the primary cloud is unavailable. The most capable version is a single RTX 5090 32GB hosting Kimi K2.7 Code, running interactively for the lead engineer and as a batch reviewer for the rest of the team. Both are real, both are buyable today, and both insulate you from the next regulatory disable order.
If you want to compare cards and CPU choices in detail before you buy, check our per-LLM model hardware requirements guide and vLLM vs llama.cpp on a single RTX 3060 12GB. Pair that with the MSI RTX 3060 Ventus 2X 12GB product page for the card SKU we recommend for first-time local-LLM builders.
Related guides
- Per-LLM Model Hardware Requirements Guide 2026
- vLLM vs llama.cpp on a Single RTX 3060 12GB in 2026
- Mistral AI's 3 Billion Euro Raise: Local vs Cloud in 2026
- OpenAI Codex Price War: Local Coding on the RTX 3060 in 2026
Bottom line
As of 2026, Claude Fable 5 was disabled by US regulatory order, not by Anthropic policy, and the partner-cloud carveouts are narrow. If your agentic coding workflow depended on it, the realistic move this quarter is a local fallback: an MSI RTX 3060 12GB Ventus 2X running DeepSeek Coder V3 21B for the cheapest legitimate entry point, or an RTX 5090 32GB running Kimi K2.7 Code or Qwen 3.5 Coder 32B for a near-peer replacement. Breakeven against cloud Fable pricing arrives inside two months for a single serious developer. Buy the GPU. Own the model. The next disable order will not warn you in advance either.
