Fable 5 in Claude Code: Model Routing, Limits, and When to Still Use Opus

TL;DR

• Enable it: /model fable. Requires Claude Code v2.1.170+ (claude update). Fable 5 is not the default on any plan.
• Cost: $10/$50 per million input/output tokens at launch — double Opus 4.8. On subscriptions it drains your usage roughly twice as fast.
• The clock: included on Pro, Max, Team, and seat-based Enterprise plans only through June 22, 2026. From June 23 it needs usage credits.
• There is no fableplan. The only built-in hybrid alias is still opusplan. Plan-with-Fable/execute-with-Opus is a manual two-command workflow or a subagent topology.
• Routing that works: Fable as the orchestrator, execution pushed to subagents pinned via model: frontmatter (sonnet or haiku). Early adopters report no visible quality drop and a much smaller bill.
• Biggest gotcha: safety classifiers bounce flagged requests to Opus 4.8 and the session stays on Opus. Your own CLAUDE.md or MCP config can trigger this on the first message.

What Fable 5 actually is

Claude Fable 5 (API ID claude-fable-5) is Anthropic’s description, verbatim, “a Mythos-class model that we’ve made safe for general use” — the public version of Claude Mythos 5, the same underlying model that ships without cybersecurity safeguards only to vetted partners. It launched June 9, 2026 with a 1M-token context window, up to 128K output tokens, and launch pricing of $10 per million input tokens and $50 per million output — exactly double Opus 4.8.

Inside Claude Code, the model-config docs position it precisely: “the most capable model in Claude Code, suited to tasks larger than a single sitting.” It investigates before acting, verifies its own work with less prompting, and holds multi-hour sessions without losing the thread. Simon Willison, after a day of testing, called it “something of a beast” and noted “the challenge is finding tasks that it can’t do.” He also burned $110.42 of API credit in one day. Both facts matter equally for what follows.

The honest one-line comparison: Opus 4.8 is the default flagship and remains the right tool for scoped work. Sonnet 4.6 is the daily driver. Fable 5 is the model you route specific work to — and routing is a skill Claude Code now expects you to have.

How to enable Fable 5 in Claude Code

Four mechanisms, in the priority order Claude Code resolves them. All verified against the current docs:

# 1. During a session — switches immediately and (since
#    v2.1.153) saves as your default for new sessions
/model fable

# 2. At startup — this session only
claude --model fable

# 3. Environment variable — this terminal only
export ANTHROPIC_MODEL=fable

# 4. Settings file — permanent until changed
# ~/.claude/settings.json
{
  "model": "fable"
}

Three things people miss, pulled straight from the docs and the bug reports:

• Version floor. Fable 5 requires Claude Code v2.1.170 or later. Older versions don’t show it in the /model picker at all — the source of the “can’t select Fable 5 in Claude Code” threads on launch day. Run claude update first.
• The best alias. /model best resolves to Fable 5 where your organization has access, otherwise the latest Opus. Useful in shared settings files that span accounts with and without Fable access.
• Zero data retention excludes you. Fable 5 is not available under ZDR agreements — the picker omits it or shows it disabled. Anthropic requires 30-day traffic retention for Fable traffic, per TechCrunch’s launch coverage, to “defend against complex and novel attacks.”

One more default worth knowing: thinking cannot be turned off on Fable 5. The session toggle and MAX_THINKING_TOKENS=0 have no effect; the model decides per step how much to think based on your /effort level (default high; max and ultracode exist and are the fastest known way to vaporize a usage window — see the limits section).

The routing playbook: plan with Fable, execute with something cheaper

First, the fact that kills the most common assumption: there is no fableplan alias. The only built-in hybrid mode in Claude Code is opusplan — Opus during plan mode, Sonnet during execution. Nothing in the current docs plans with Fable and hands off automatically. If you want Fable’s planning with cheaper execution, you have three real options.

Option 1 — manual switch at the plan boundary

/model fable        # plan mode: investigate, scope, write the plan
# ... review and accept the plan ...
/model opus         # execution: implement against the plan
# (or /model sonnet if the plan is detailed enough)

Crude, free of moving parts, and it works today. The catch the docs flag: switching models mid-conversation re-reads the full history without cached context on the next response, so each switch has a one-time token cost. Switch at the plan boundary, not every other message.

Option 2 — Fable writes artifacts, Opus executes later

This is the pattern the r/ClaudeCode thread “Plan with Fable, execute with Opus?” converged on, and it’s the one we’d endorse for the free-window deadline: don’t hand Opus a pile of prose, hand it an executable artifact.

Another commenter in the same thread pointed at the limit of the whole approach: “a lot of fable’s best use is the fact that it can basically write scripts and create its own tooling for validation and debugging. opus wont be able to do that.” The fix is to make tooling part of the deliverable — have Fable write the validation scripts and test harnesses into the repo during planning, so the executing model inherits them instead of needing to invent them.

Option 3 — Fable orchestrates, cheap subagents execute

Invert the question: instead of planning on the expensive model and executing on the cheap one, keep Fable as the main conversation and push token-heavy execution into subagents pinned to cheaper models. That’s the next section, because it’s the most mechanical and least understood.

Subagent model overrides: the cost-tiering machinery

A subagent — a worker conversation with its own context window, system prompt, and tool allowlist — takes a model field in its YAML frontmatter. Per the subagents docs, accepted values are sonnet, opus, haiku, fable, a full model ID like claude-opus-4-8, or inherit (the default — same model as the main conversation).

# .claude/agents/implementer.md
---
name: implementer
description: Executes a written plan step. Use for scoped,
  well-specified implementation tasks with clear file boundaries.
model: sonnet
---
You implement exactly one plan step at a time. Read the plan file,
implement the step you are given, run the verification command the
plan specifies, and report the diff summary.

# .claude/agents/grunt-search.md
---
name: grunt-search
description: Broad codebase search and file inventory. Returns
  only conclusions, never raw file dumps.
model: haiku
---
You search and summarize. You never edit files.

The resolution order matters when things don’t behave — the docs specify it exactly:

1. CLAUDE_CODE_SUBAGENT_MODEL environment variable, if set — overrides everything, for all subagents
2. The per-invocation model parameter Claude passes
3. The subagent definition’s model frontmatter
4. The main conversation’s model

That first line is the classic foot-gun: if you exported CLAUDE_CODE_SUBAGENT_MODEL=haiku months ago to save money, your carefully pinned model: fable review agent is silently running on Haiku. Set it to inherit or unset it to restore normal resolution.

Does the Fable-orchestrator/cheap-worker topology actually hold up? Early signal says yes:

This makes architectural sense. The orchestrator’s job — decomposition, sequencing, judging results — is exactly the long-horizon reasoning Fable is built for, while the workers’ jobs are scoped enough that Sonnet’s quality is indistinguishable. It’s the same logic as the subagent-driven-development skill, with a price gradient attached. Our opinionated default tiering: Fable for the main session on gnarly work, Sonnet subagents for implementation, Haiku subagents for search and inventory. If you’re unsure where subagents fit versus skills and hooks, the skills vs subagents vs plugins vs hooks breakdown covers the boundaries.

The silent Opus fallback (and why it fires on message one)

Fable 5 ships with safety classifiers for cybersecurity and biology content. When one flags a request, Claude Code re-runs that request on Opus 4.8, shows a notice in the transcript, and — the part everyone misses — the session then continues on Opus until you run /model fable again. Anthropic says “more than 95% of Fable sessions involve no fallback at all,” which means roughly 1 in 20 does.

The counterintuitive failure mode, straight from the docs: fallback can trigger on the first request of a session, before you send anything unusual, because that request carries workspace context — your CLAUDE.md, git status, directory names. A repo with security tooling, pentest notes, or biology-adjacent code can trip the classifier on context alone. Diagnosis and control:

# Test whether your customizations are the trigger:
# --safe-mode disables CLAUDE.md, skills, MCP servers, and hooks
claude --safe-mode

# Prefer a prompt instead of an automatic switch:
# /config → turn off "switch models when a message is flagged"
# A flagged request then pauses: switch to Opus, or edit and retry on Fable

One more wrinkle with a short shelf life: at launch there was also an invisible intervention for frontier-AI research queries — no notice, just degraded output. After researchers called it “secret sabotage” (Dean Ball’s phrase, in Fortune’s reporting), Anthropic reversed it within a day: “We made the wrong tradeoff, and we apologize for not getting the balance right.” The visible cyber/bio fallback described above remains, and is documented behavior, not a bug.

Limits, the June 22 cliff, and what actually burns usage

The arithmetic first, because it explains every angry thread. At launch, per million tokens: Haiku 4.5 $1/$5, Sonnet 4.6 $3/$15, Opus 4.8 $5/$25, Fable 5 $10/$50. Fable is 2x Opus per token, and on subscription plans it draws down your 5-hour and weekly limits correspondingly faster. Stack max or ultracode effort on top — unconstrained thinking-token spend — and the multiplier compounds.

Read the configuration in that report, not just the outrage: two parallel sessions, max effort, ultracode — the three most expensive switches in Claude Code, all on, unattended. Fable at default high effort in one session is a different product. Still expensive, not that.

The calendar matters more than the multiplier. Fable 5 is included at no extra cost on Pro, Max, Team, and seat-based Enterprise plans from June 9 through June 22, 2026. From June 23 it requires usage credits at API rates on top of your subscription — Anthropic says it intends to bring it back as a standard plan feature “as soon as possible,” with no date attached. The most-upvoted cost analysis on r/ClaudeCode, “Did the math on Fable 5”, put the structural complaint best: “every generation a new tier appears on top at double the previous flagship. The model you can afford is always one tier below the model in the benchmarks.”

Practical guidance for the window: don’t spend it one-shotting toy demos. Spend it on the backlog of ambiguous, multi-session problems — the architecture untangle, the flaky-test root cause, the migration plan — and have Fable leave artifacts (plans, scripts, CLAUDE.md updates) that outlive June 22. The Claude Code best-practices guide covers the session-hygiene half of keeping any model’s token bill sane.

What we got wrong

Three assumptions we carried into this research that did not survive contact with the docs:

• We assumed a fableplan alias existed. It doesn’t. We’d internally sketched this post around “just use fableplan” before checking; the only hybrid alias is opusplan, unchanged.
• We assumed the Opus fallback was per-request. It’s stickier: after a flagged request, the session continues on Opus until you manually switch back. If you never check your status line, you can run half a day on the wrong model.
• We blamed the model for the limit horror stories. Reading the actual threads, the worst reports combine Fable with max/ultracode effort and parallel sessions. The model is 2x; the configurations people ran were not 2x.

What it means for MCP and skills users

Short answer: nothing changes mechanically, two things change practically. MCP servers speak the same protocol to Fable 5 as to every other model; skills load the same SKILL.md the same way; hooks fire identically. If your Claude Code setup works on Opus, it works on Fable. The decision logic for which extension primitive to reach for is also model-independent — that’s the Skills vs MCP vs subagents decision matrix.

The two practical shifts:

• Your config is now classifier input. CLAUDE.md content, skill descriptions, and MCP tool surfaces ride along in the first request. A security scanner MCP server or a pentest-focused skill can trip the cybersecurity classifier and bounce the session to Opus before your first real prompt. claude --safe-mode is the bisection tool.
• Less steering needed, same tools. The docs are explicit that Fable verifies its own work with less prompting and generalizes to unfamiliar tools — one Cognition quote from the announcement: it “generalizes to unfamiliar tools out of the box.” In practice: trim the “remember to run the tests” boilerplate from your CLAUDE.md when running Fable; it’s spending your tokens reading instructions it doesn’t need.

Community signal: did Fable meet the Mythos hype?

The honest answer from the people paying for it is “yes, with an asterisk shaped like a price tag.” The r/ClaudeCode thread “Did Fable meet the Mythos Hype?” collected 80+ comments in a day; the top comment is the contrarian one:

The positive reports in the same thread cluster around exactly what the docs predict: long unattended runs (“multiple 45 minute runs”), mathematical research “far smarter than Opus 4.8 max,” and code review across projects. The negative reports cluster around cost and the June 22 deadline, not capability. That split — capability praised, access model resented — is the most consistent signal across every thread we read.

Verdict

Frequently asked questions

Glossary

• Fable 5 — Anthropic’s most capable generally available model (API ID claude-fable-5), launched June 9, 2026.
• Mythos 5 — the same model without cybersecurity safeguards, restricted to vetted partners.
• Model alias — a short name (fable, opus, sonnet, haiku, best) that resolves to the recommended model version for your provider.
• opusplan — the built-in hybrid alias: Opus in plan mode, Sonnet in execution. No Fable equivalent exists.
• Subagent — a worker conversation with its own context window, system prompt, tool allowlist, and optionally its own model.
• CLAUDE_CODE_SUBAGENT_MODEL — env var that forces one model for all subagents, overriding frontmatter.
• Automatic model fallback — Fable’s classifier-triggered re-run of a flagged request on Opus 4.8; the session stays on Opus afterward.
• --safe-mode — launch flag that disables CLAUDE.md, skills, MCP servers, and hooks, to test whether customizations trip the classifier.
• Effort level — adaptive-reasoning dial (low to max, plus ultracode); the main cost lever on Fable since thinking can’t be disabled.
• Usage credits — pay-as-you-go balance on subscription plans; required for Fable 5 after June 22, 2026.

Sources

Primary

• anthropic.com/news/claude-fable-5-mythos-5 — launch announcement; pricing, safeguards, “more than 95% of Fable sessions involve no fallback”
• code.claude.com/docs/en/model-config — aliases, precedence, fallback mechanics, effort levels, version requirements
• code.claude.com/docs/en/sub-agents — subagent model frontmatter and resolution order
• platform.claude.com — Introducing Claude Fable 5 and Claude Mythos 5 — model ID, context window, output limits

Community

• r/ClaudeCode — Terrible start to the day with Fable 5 — limits report (Max 5x, ultracode)
• r/ClaudeCode — Plan with Fable, execute with Opus? — routing patterns, artifact handoff
• r/ClaudeCode — Did Fable meet the Mythos Hype? — capability vs cost sentiment
• r/ClaudeCode — Did the math on Fable 5 — pricing tiers, June 22 analysis
• r/ClaudeCode — Fable orchestrating Sonnet subagents — orchestrator/worker topology report
• @claudeai launch post — first-party announcement, June 9, 2026

Press & contrarian

• simonwillison.net — Initial impressions of Claude Fable 5 — “something of a beast,” $110.42/day spend
• TechCrunch — Claude Fable 5 launch coverage — availability windows, 30-day retention requirement
• Fortune — “secret sabotage” accusation and Anthropic’s reversal — the invisible-intervention episode

Internal

• /blog/claude-code-best-practices
• /blog/claude-skills-vs-mcp-vs-subagents-vs-cli-2026-decision-matrix
• /blog/claude-code-skills-vs-subagents-vs-plugins-vs-hooks-2026
• /skills/subagent-driven-development
• /skills — browse all
• /clients/claude-code