Claude Fable 5: when to use Fable, Opus, and Sonnet without burning money

Claude Fable 5 is not another small model bump. Anthropic is presenting it as the first generally available Mythos-class Claude model, a tier above Opus, built for long-running coding, research and knowledge-work tasks that previous models struggled to hold together.

That does not mean every team should switch everything to Fable tomorrow.

Fable 5 is expensive. It has stricter safety routing than other Claude models. It also comes with a 30-day data-retention requirement for safety monitoring. For many ordinary jobs, Claude Sonnet or Claude Opus will still be the better business decision.

The useful question is not: "Is Fable 5 the best model?" The useful question is: where does Fable 5 change the economics of a task enough to justify the cost and risk?

Source: Anthropic's Claude Fable 5 product page, Anthropic announcement, Claude model documentation.

What Anthropic actually launched

Anthropic launched two closely related models on June 9, 2026:

• Claude Fable 5: the generally available version, with stronger safeguards for public use.
• Claude Mythos 5: the restricted version for approved partners through Project Glasswing, with some safeguards lifted for specific defensive or research use cases.

The important detail: Anthropic says Fable 5 and Mythos 5 are based on the same underlying model. The difference is deployment. Fable 5 is the safety-hardened public version.

Anthropic's own positioning is direct: Fable 5 is its most capable widely released model and is meant for demanding reasoning, long-horizon agentic work, complex coding, deep knowledge work, vision-heavy tasks, and projects that may run for hours or days.

The official model details that matter for implementation:

• API model ID: claude-fable-5
• Context window: 1 million tokens
• Maximum output: 128k tokens
• Input price: $10 per million tokens
• Output price: $50 per million tokens
• Prompt cache read price: $1 per million tokens
• Prompt cache write price: $12.50 per million tokens for 5-minute cache writes, or $20 per million tokens for 1-hour cache writes
• US-only inference: available on supported Anthropic platforms at a 1.1x multiplier
• Adaptive thinking: always on
• Availability: Claude API, Claude Platform on AWS, Amazon Bedrock, Vertex AI, Microsoft Foundry and selected product surfaces

Source: Claude model overview, Claude pricing documentation, AWS Bedrock model card.

The short version: what Fable 5 is for

Use Fable 5 when the work is genuinely hard and the value of solving it is high.

Good Fable 5 jobs:

• A codebase-wide migration where the model must understand many files and keep a plan alive for hours.
• A stubborn production bug that already wasted human time.
• A deep research task where the model must read many sources, reconcile contradictions, and produce a decision-ready brief.
• A product or engineering plan where the cost of a shallow answer is high.
• A vision-heavy workflow, such as comparing UI screenshots, reading complex charts, or turning design intent into code.
• An autonomous task with tests, checkpoints, and a clear definition of done.

Bad Fable 5 jobs:

• Simple copywriting.
• Routine code edits.
• First-pass summarization.
• Customer support drafting.
• Formatting, translation, cleanup, or classification.
• Any workflow where 30-day retention is not acceptable.
• Any task where you cannot verify the output.

Fable is a specialist tool. Treating it as the default model is like using a senior architect to rename files.

Why people are excited

The launch story is unusually aggressive. Anthropic says Fable 5's lead grows as tasks get longer and more complex. That is the part to pay attention to.

Small prompts often hide model differences. A short answer, a small function, or a one-page summary may look similar across Sonnet, Opus, and Fable. The gap appears when the model has to maintain state, make tradeoffs, use tools, recover from errors, and keep moving without constant hand-holding.

That is why most serious reviews focused on long-running coding and agentic work, not chat answers.

Relevant reported examples:

• Stripe early testing: Anthropic says Fable 5 performed a codebase-wide migration in a 50-million-line Ruby codebase in a day, work that would otherwise have taken a full team far longer.
• GitHub Copilot: GitHub says Fable 5 is available in Copilot and, in internal autonomous coding benchmarks, completed equivalent work with fewer tool calls and lower token consumption than previous Opus-tier models.
• Reviewers testing Claude Code reported stronger one-shot app building, better multistep execution, and stronger autonomous loops, while also warning that the model can burn tokens fast.

Treat vendor examples as directional, not universal proof. They show what the model is designed for. They do not mean your repo, test suite or business process will get the same result.

Sources: Anthropic announcement, GitHub Copilot changelog, Every hands-on review, Better Stack overview.

The safety catch: Fable can become Opus

Fable 5 is powerful enough that Anthropic added broader safeguards than normal. Those safeguards review not just your latest prompt, but the full context the model can read: conversation history, files, memory, connector data and web search results.

If the safeguards flag a request, many Claude products route the request to Claude Opus 4.8 instead. Anthropic says this is most relevant for:

• Cybersecurity
• Biology
• Chemistry
• Model distillation or attempts to extract model reasoning
• Some frontier-LLM-development assistance

This matters for two reasons.

First, you may think you are using Fable when the answer actually comes from Opus. Claude should notify you in product surfaces, but teams building through APIs need to design for this explicitly.

Second, false positives are expected. A benign security review, a healthcare document, a biotech market analysis, or a codebase containing exploit-related test fixtures can trigger a fallback because the classifier looks at the whole context.

This is not a bug to work around. It is a deployment rule to plan around.

The right response is not: "How do we bypass the guardrail?" The right response is: "Should this task use Opus, a restricted approved program, or a different internal workflow?"

Sources: Claude Help Center on Fable model switching, Claude Fable 5 and Mythos 5 system card.

The data-retention catch

Fable 5 has a different data-handling profile from other Claude models.

Anthropic and GitHub both state that Fable 5 traffic can be retained for up to 30 days for safety systems. The retained data is not used for model training, but it is still retained.

That single detail should decide many enterprise routing policies.

Use Fable carefully if your inputs include:

• Customer personal data
• Confidential contracts
• M&A material
• Unreleased product strategy
• Security-sensitive architecture
• Healthcare, biotech or regulated research material
• Client data under strict deletion or residency requirements

If Zero Data Retention is required, Fable 5 may be the wrong model even when it is technically the most capable. In those cases, use Opus or Sonnet under the appropriate data terms, or keep the work inside an approved enterprise setup.

Sources: GitHub Copilot changelog, Anthropic commercial terms, Claude data residency documentation.

Cost: the number that changes behavior

Fable 5 costs twice as much as Opus 4.8 and more than three times as much as Sonnet 4.6 on both input and output tokens.

Official prices:

• Fable 5: $10 input / $50 output per million tokens
• Opus 4.8: $5 input / $25 output per million tokens
• Sonnet 4.6: $3 input / $15 output per million tokens
• Haiku 4.5: $1 input / $5 output per million tokens

A simple example:

• A 100k-token input and 20k-token output costs about $2.00 on Fable, $1.00 on Opus, $0.60 on Sonnet and $0.20 on Haiku.
• A 1M-token input and 100k-token output costs about $15.00 on Fable, $7.50 on Opus, $4.50 on Sonnet and $1.50 on Haiku.
• If the 1M-token Fable input is a prompt-cache read, that same 1M input costs about $1.00 instead of $10.00, before output tokens.

The last point is the real optimization lever. Fable is expensive, but repeated large context is where teams accidentally light money on fire. Prompt caching can cut stable input context by 90%, while output tokens remain expensive.

Sources: Claude pricing documentation, Claude prompt caching documentation. Cost examples calculated from official token prices.

When to use Claude Sonnet

Sonnet should stay the default for most teams.

Use Sonnet for:

• Daily coding help
• Routine bug fixes
• First drafts
• Internal documentation
• Support macros
• Lightweight research
• Summaries
• Data extraction
• Task triage
• Workflow automation where speed and cost matter

Sonnet is usually the best model for high-volume work because it is fast, strong and much cheaper than Fable. If a task can be checked quickly by a human or by tests, Sonnet is often enough.

A practical rule: start with Sonnet unless you can explain why the job needs more.

When to use Claude Opus

Opus is the serious-work default when Fable is too expensive, too restricted, or too sensitive from a data-retention perspective.

Use Opus for:

• Hard reasoning that does not need Fable-level autonomy
• Complex architecture decisions
• High-quality review of Sonnet-generated work
• Sensitive work where Fable's retention requirement is not acceptable
• Cybersecurity, biology, or medical-adjacent material that would likely trigger Fable's safety fallback anyway
• Executive memos and strategic synthesis where you need quality but can still manage the process actively

Opus is also the right fallback when Fable gets too conservative. If a safe request keeps getting routed away from Fable, forcing the issue is usually a waste of time. Move to Opus, reduce the context, or split the task into safer subproblems.

When to use Claude Fable 5

Use Fable when the task has one or more of these properties:

• It is long-running.
• It requires many tool calls.
• It has a large codebase or document set.
• It needs planning, execution and self-verification.
• It failed on Sonnet or Opus in a way that matters.
• It is valuable enough that a $10 or $50 model session is still cheap compared with human time.
• You can test or review the result.
• You accept the data-retention rules.

Fable should not be "the smart model we use for everything." It should be the escalation model for jobs where the model's extra persistence changes the outcome.

The combined model stack that makes sense

The best Fable setup is not "use Fable everywhere." It is a routed stack.

A good workflow looks like this:

1. Use Sonnet to gather context, summarize sources, inspect files and draft the first plan.
2. Use Opus to challenge the plan, find missing assumptions and decide whether the job deserves Fable.
3. Use Fable for the hard execution loop: large migration, deep synthesis, autonomous coding, or complex multistep research.
4. Use Sonnet again for cleanup, formatting, documentation, and smaller follow-up edits.
5. Use Opus or a human expert for final review when the decision is important.

For coding teams:

• Sonnet handles issue triage, small edits and test scaffolding.
• Opus handles architecture, PR review and tricky debugging.
• Fable handles the large migration, the multi-hour refactor, the vague but important backlog item, or the hard integration project.

For non-technical teams:

• Sonnet drafts and summarizes.
• Opus turns messy inputs into a decision memo.
• Fable runs the full research-and-deliverable project when the output will guide real money, hiring, compliance or operational decisions.

For agencies and consultants:

• Sonnet is the production assistant.
• Opus is the senior analyst.
• Fable is the special-project partner you use when the client problem is broad, ambiguous, and valuable.

How to prompt Fable 5 differently

Fable appears to work best when you stop micromanaging every step.

The useful pattern is:

1. Give it the goal.
2. Give it constraints.
3. Let it interview you for missing requirements.
4. Ask for a plan before execution.
5. Define success criteria.
6. Tell it what tests, checks or review steps must pass.
7. Let it run in a loop, but require checkpoints before risky actions.

Example prompt for a coding task:

I want to migrate this feature from the old billing module to the new billing service.

Before editing, inspect the repo and ask me any questions that materially affect the migration.

Then create a plan with:
- files likely to change
- tests to run
- risks
- rollback strategy
- success criteria

Do not make destructive changes without approval.
After implementation, run the relevant tests, inspect the diff, and summarize anything a human reviewer should check.

Example prompt for research:

Research whether we should adopt [tool/vendor] for [business process].

Use official documentation first, then credible independent reviews. Separate verified facts from claims and opinions. Flag pricing, data retention, lock-in, security risks and integration work.

Before writing the recommendation, show me the decision criteria you will use. The final output should include a recommendation, a cheaper alternative, a risk register and the first three implementation steps.

Fable should be given room, not a blank check.

Token optimization: how not to burn the budget

If you use Fable like a normal chat model, it will get expensive fast.

Use these rules:

• Do not paste everything. Retrieve only the files, documents or excerpts needed for the current step.
• Put stable instructions, tool schemas and long reference material behind prompt caching.
• Keep dynamic data after the cache breakpoint so small changes do not break the cache.
• Use Sonnet to compress research notes before escalating to Fable.
• Ask for plans and diffs, not long essays, during execution.
• Set explicit output budgets: "keep the answer under 1,200 words unless a test failure requires detail."
• Use checkpoints: after planning, after implementation, after verification.
• Avoid repeated full-context retries. If the model fails, summarize the failure and retry with a smaller prompt.
• Track cost per task, not just cost per token. A $15 Fable session that replaces a day of senior work is cheap. A $15 formatting session is waste.
• For agents, set spending limits, max turns, allowed tools and stop conditions.

Prompt caching is especially important. Fable cache reads are $1 per million tokens instead of $10. But cache writes cost extra, and output tokens still cost $50 per million. Caching helps most when the same large prefix is reused across several turns or similar jobs.

Safe operating rules for Fable agents

Fable makes autonomous work more attractive. That also makes operational safety more important.

For coding:

• Run it in a branch or worktree.
• Use tests as the definition of done.
• Require approval for deletes, migrations, deployments and credential changes.
• Deny access to .env, secrets, production databases and customer data unless explicitly needed.
• Keep a human review gate before merge.
• Ask it to produce a risk note with the diff.

For research:

• Require source links.
• Separate official sources from commentary.
• Ask for confidence levels.
• Ask for contradictions and missing data.
• Never let it invent citations.

For business workflows:

• Define what the model is allowed to decide and what must go to a person.
• Keep audit logs.
• Avoid sending sensitive personal data unless retention and privacy terms are acceptable.
• Treat the output as a recommendation, not an authority.

Fable is strongest when it can work independently inside a bounded sandbox. It is weakest, and most dangerous, when it has broad tools, vague goals and no review gate.

What the YouTube reviews add

The official Anthropic video is short and mainly explains the launch narrative: Fable 5 is a public Mythos-class model, Anthropic restricted earlier Mythos access because of cyber risk, and Fable routes high-risk cyber and biology requests to Opus 4.8.

Independent reviewers mostly agree on the broad pattern:

• Fable looks the strongest on long tasks, coding loops, and ambitious one-shot builds.
• It can be token-hungry.
• It is not a good default for cheap everyday work.
• Some reviewers are worried about the 30-day retention requirement and broad safeguards.
• Hands-on coding demos are impressive, but still need tests and human review.

Useful videos:

• Anthropic: Introducing Claude Fable 5 — official launch explanation; best for the safety and positioning narrative.
• Every: We Tested Anthropic's Fable 5 for a Week — hands-on early-access review; useful for real-work expectations and the "do not overreact on day zero" caveat.
• Better Stack: Claude Mythos is FINALLY here (Fable 5) — concise benchmark and pricing overview with hands-on UI/code examples.
• Developers Digest: Claude Fable 5 in 7 Minutes — fast summary of benchmark claims, pricing and usage recommendations.
• Alex Finn: Claude Fable 5 just dropped and I'm speechless — enthusiastic Claude Code workflow demo; useful for seeing the "goals and loops" style, but treat the claims as creator opinion, not neutral evaluation.
• AI for Work: I Tested Claude Fable 5. 4 Wild Tests — practical demo orientation; useful as a secondary review source.
• AsapGuide: I Tested Claude Fable 5 Against Opus — relevant for cost/performance comparison, if you want a creator's side-by-side testing lens.
• BridgeMind: Vibe Coding With Claude Fable 5 — long live session; useful as raw demonstration material, not as a concise explainer.

Risks and limitations

The main Fable risks are practical, not abstract.

First, cost. A long agent loop can spend real money before anyone notices. Teams need budgets and stop conditions.

Second, retention. Some organizations simply cannot send certain data to a model with 30-day retention.

Third, false positives. Fable may route safe work to Opus if the context touches sensitive domains.

Fourth, over-trust. The model may be more capable, but it still needs tests, source checks and human judgment.

Fifth, benchmark confusion. Some benchmark numbers discussed online mix Fable and Mythos, or show the stronger unsafeguarded capability in domains where public Fable may fall back. Be careful when comparing scores.

Sixth, autonomous-tool risk. A better agent can make bigger mistakes if it has broad permissions.

The model did not remove governance. It raised the price of not having governance.

Recommended policy for Hammer-style teams

For a practical business using Claude models, I would set the policy like this:

• Default model: Sonnet.
• Escalation model: Opus.
• Special-project model: Fable.
• Cheap background model: Haiku, where available.

Escalate to Opus when:

• Sonnet gets stuck twice.
• The task needs deeper reasoning.
• The output will influence a business decision.
• The context is sensitive, and Fable retention is not acceptable.

Escalate to Fable when:

• Opus still struggles.
• The task is long-horizon.
• The expected value is high.
• The input data is allowed under Fable retention terms.
• You have tests or review steps.
• The task can be bounded with permissions and stop conditions.

Step down from Fable when:

• The task becomes routine.
• The model starts producing long explanations instead of useful work.
• The context triggers safety fallbacks.
• The cost per useful output becomes hard to justify.
• You are cleaning up, formatting or translating.

Final take

Claude Fable 5 is probably the first Claude model where the right usage pattern looks less like chat and more like delegation.

That is the opportunity. Give it the messy, high-value work that normally dies between planning and execution. Let it ask questions. Let it plan. Let it run against tests. Then review the result like you would review a strong but very expensive contractor.

But do not use it as the default assistant.

Most work should still start with Sonnet. Hard work should move to Opus. Fable should come in when the task is valuable, long, difficult and verifiable enough to justify the cost, the retention rule and the operational risk.

That is where Fable 5 can be genuinely useful: not as a smarter chatbot, but as a bounded special-project agent.