Claude Fable 5 for AI Coding in 2026: Tested as a Cursor and Cline Backend

By AICoderScope Team · 11 min read
claudereviewcursorclinepricingai

TL;DR: Claude Fable 5 is the strongest coding model you can buy today — 80.3% on SWE-bench Pro, well ahead of Opus 4.8 — but at $10/$50 per million tokens it is exactly double Opus 4.8. For most agentic coding it is overkill. Use the free Pro/Max window (ends June 22) to test it, then route to it only for the hard 20% of tasks.

Claude Fable 5Claude Opus 4.8GPT-5.5
Best forThe hardest agentic tasks, long-horizon refactorsDaily agentic coding, best price/performanceCheaper agent runs, Copilot/Codex users
Price (in / out per M)$10 / $50$5 / $25~half Fable’s input
SWE-bench Pro80.3%69.2%58.6%
The catch2× the token bill; reroutes to Opus 4.8 on restricted topicsNot as strong on the gnarliest tasksTrails both on agentic coding

Honest take: Fable 5 is the best, and you should not run it as your default. Keep Opus 4.8 (or a cheaper model) on the wheel and reach for Fable 5 only when a task actually defeats it. The June 22 free window is the one time to use it freely — burn through your hardest backlog before then.

What Fable 5 actually is

Anthropic shipped Claude Fable 5 on June 9, 2026 — the first publicly available “Mythos-class” model, a tier above Claude Opus 4.8. It shares the same underlying model as Claude Mythos 5, the frontier system Anthropic keeps gated. The difference is safety: Fable 5 runs with production safeguards across cybersecurity, biology, chemistry, model distillation, and frontier-AI-development topics. Mythos 5 itself stays restricted to Glasswing partners and a small set of biology researchers who get those guardrails lifted.

The safeguard mechanism matters for developers in one specific way: when a request trips one of those restricted categories, Fable 5 hands the response off to Opus 4.8 instead. For ordinary application code this never fires. If you write security tooling, exploit research, or anything that brushes the cyber category, you may silently get an Opus 4.8 answer rather than a Fable 5 one. It is not an error — it is the design — but it is worth knowing before you wonder why a “Fable 5” run felt like Opus.

The headline specs: a 1M-token context window by default and up to 128k output tokens per request. The API model ID is claude-fable-5, and it launched simultaneously on the Claude API, Amazon Bedrock, Google Vertex AI, Microsoft Foundry, and inside GitHub Copilot and Claude Code.

The benchmark numbers that actually matter for coding

Anthropic positioned Fable 5 as a coding and science leap, and the agentic-coding numbers back that up. On Anthropic’s own SWE-bench Pro table, the model lands at 80.3%, with Opus 4.8 at 69.2%, GPT-5.5 at 58.6%, and Gemini 3.1 Pro at 54.2%. That is the widest gap between an Anthropic flagship and the field in a couple of release cycles.

BenchmarkClaude Fable 5Claude Opus 4.8Notes
SWE-bench Pro80.3%69.2%Anthropic-reported; the harder, contamination-resistant set
SWE-bench Verified~95%—Reported by independent trackers; treat as ceiling, not floor
Terminal-Bench 2.188.0%—Long-horizon terminal/agentic tasks
Context window1M tokens1M tokensSame ceiling as Opus 4.8
Max output128k tokens—Useful for whole-file rewrites

A caveat on SWE-bench Verified: the ~95% figure circulating from independent trackers is impressive, but Verified is a saturating benchmark and several teams have flagged contamination concerns across the 2026 model wave. SWE-bench Pro — newer, harder, and built to resist memorized solutions — is the more honest signal, and that is where the 11-point lead over Opus 4.8 lives. Eleven points on Pro is real; do not anchor on the 95%.

What does that translate to in practice? On a multi-file refactor where Opus 4.8 gets stuck re-reading the same files or proposes a change that breaks a downstream import, Fable 5 is materially more likely to hold the whole dependency graph in its head and land the change in one pass. On a 40-line bug fix, you will not notice the difference — and you will pay double for the privilege.

Pricing: the part that hurts

Fable 5 costs $10 per million input tokens and $50 per million output tokens. That is exactly 2× Claude Opus 4.8, which sits at $5 / $25 and has not moved since Opus 4.7. It is also roughly double GPT-5.5 on input.

Agentic coding is output-heavy and context-heavy — agents re-read files, generate diffs, run tools, and re-read again. A single non-trivial agent task on a real repo can chew through 200k–500k input tokens and 30k–80k output tokens once you count the back-and-forth. Run the math at Fable 5 rates:

Example: one medium agentic task
  Input:  400,000 tokens × $10 / 1M  = $4.00
  Output:  60,000 tokens × $50 / 1M  = $3.00
  ----------------------------------------
  Fable 5 total per task             ≈ $7.00

Same task on Opus 4.8 ($5 / $25):
  Input:  400,000 × $5  / 1M = $2.00
  Output:  60,000 × $25 / 1M = $1.50
  ----------------------------------------
  Opus 4.8 total per task   ≈ $3.50

Ten tasks a day on Fable 5 is ~$70/day, ~$1,400/month, before you cache anything. That is the number that should make you pause. Two things blunt it: prompt caching reads run at roughly 0.1× base input, and the Batch API takes 50% off both directions for non-interactive jobs. Neither helps an interactive Cursor session much, where you are paying full freight on fresh context every turn.

The June 22 free window — what to do with it

From launch on June 9 through June 22, Fable 5 is included at no extra cost on Pro, Max, Team, and seat-based Enterprise plans. On June 23 it is removed from those plans, and continued use requires credits or API billing.

This is the single most useful fact in this article. For roughly two weeks you can run the best coding model in the world against your hardest problems without watching a token meter. Concrete plan:

  1. Pull your “too hard for the agent” backlog forward. The refactors you keep deferring because Opus 4.8 fumbles them — do them now, on Fable 5, while it is free.
  2. Run it inside Claude Code, where the model picker and --model claude-fable-5 flag let you switch per-session without touching API keys.
  3. Benchmark it on your own repo, not on Twitter screenshots. Give it the same gnarly task you gave Opus 4.8 last week and compare the diffs.
  4. Decide before June 23 whether any of your work genuinely needs it at $10/$50, or whether routing covers you.

After June 22, the calculus flips hard toward “route, don’t default.”

Setting it up as your coding backend

Claude Code is the path of least resistance. Select Fable 5 from the model picker, or pin it for a session:

# One-off session on Fable 5
claude --model claude-fable-5

# Inside an existing session, switch with /model
> /model claude-fable-5

If you run a Claude Code power-user setup with CLAUDE.md, slash commands, and subagents, you can scope Fable 5 to a single subagent that handles only the hard architectural work and leave the cheaper model on everything else.

Cursor: add Anthropic as a custom model in Settings → Models, supply your Anthropic API key, and register the model ID claude-fable-5. Note that Cursor’s own Pro request quota and its Anthropic passthrough are billed separately — using your own key bills you at Anthropic’s $10/$50 directly, which can be cheaper or more expensive than Cursor’s bundled pricing depending on volume. If you are weighing the two, our Cursor vs Claude Code comparison breaks down where each one’s billing model wins.

Cline (VS Code): open the model dropdown, pick the Anthropic provider, paste your API key, and select claude-fable-5. Cline shows a running token/cost estimate per task in the sidebar — leave it visible. On Fable 5 it is the difference between a $7 task you noticed and a $7 task you did not.

// Cline / Continue-style provider config sketch
{
  "provider": "anthropic",
  "apiKey": "sk-ant-...",
  "model": "claude-fable-5",
  "maxTokens": 128000        // Fable 5 output ceiling
}

A real cost trap, and the fix

The first day Fable 5 was billable, the most common complaint across r/ChatGPTCoding and HN was identical: “I left it as my Cursor default and burned through $40 before lunch.” The mechanism is boring and avoidable. Agent mode re-sends growing context every turn; on a long debugging session that context balloons; at $10/M input you are paying for the entire conversation history on every single message.

The fix is two-part. First, cap the model to the task, not the session — switch to Fable 5 for the one hard step, then switch back. Second, lean on prompt caching: keep your large, stable context (the repo map, CLAUDE.md, the files you are working in) at the front of the prompt so cache reads at 0.1× input absorb most of the cost on repeated turns. A session that caches well can cut the effective input bill by 70–80% versus one that reshuffles context every message.

The cleaner architectural answer is routing. Pin the bulk of your traffic — autocomplete, small edits, boilerplate — to a cheap model like Haiku 4.5 or DeepSeek V4-Flash, keep Opus 4.8 on standard agentic work, and reserve Fable 5 for the hard 20% that actually defeats Opus. That mix beats running any single premium model as your default, and it beats most flat subscriptions too.

When Fable 5 is actually worth $10/$50

Pay for Fable 5 when the failure cost of a wrong change is high and the task is genuinely hard: a cross-cutting refactor across dozens of files, a migration where a missed edge case breaks production, a long-horizon agent run that has to hold a large mental model for hours. The 11-point SWE-bench Pro lead is exactly the kind of margin that shows up on those tasks and nowhere else.

Skip it for the daily grind. CRUD endpoints, test scaffolding, small bug fixes, autocomplete — Opus 4.8 or a mid-tier model does these at parity for half (or a tenth) the cost. Paying Fable 5 rates to generate a React form is lighting money on fire.

And if your interest is keeping data and cost on your own hardware rather than chasing the frontier, a local model is the other end of this spectrum — see runaihome’s best local AI models by VRAM for what an RTX-class GPU can run as a coding backend with zero per-token cost. For open-source agent tooling that pairs with either path, aifoss.dev tracks the FOSS side.

FAQ

Is Fable 5 better than Opus 4.8 for coding? Yes, measurably — 80.3% vs 69.2% on SWE-bench Pro. But the gap only shows up on hard, multi-file, long-horizon tasks. On routine work they are effectively tied, and Opus 4.8 costs half as much.

How much does Fable 5 cost? $10 per million input tokens and $50 per million output tokens — exactly double Opus 4.8. Prompt cache reads run at ~0.1× input; the Batch API discounts both directions 50% for non-interactive jobs.

Is Fable 5 free right now? Through June 22, 2026 it is included on Pro, Max, Team, and seat-based Enterprise plans at no extra cost. On June 23 it is removed and you need credits or API billing to keep using it.

Why did my Fable 5 request return an Opus 4.8-style answer? Fable 5 reroutes restricted-topic requests (cybersecurity, biology, chemistry, distillation, frontier-AI development) to Opus 4.8 by design. Security-tooling and exploit work are the most likely triggers for ordinary developers.

What’s the model ID and where can I run it? claude-fable-5, available on the Claude API, Amazon Bedrock, Google Vertex AI, Microsoft Foundry, GitHub Copilot, and Claude Code (CLI, web, and Cowork).

Should I make it my Cursor or Cline default? No. Set it per-task, not per-session, or route the hard 20% to it and keep a cheaper model on everything else. Defaulting to Fable 5 in agent mode is the fastest way to a surprise bill.

Sources

Last updated June 12, 2026. Pricing and features change frequently; verify current state before purchasing.

Was this article helpful?