Claude Fable 5
The First Public Mythos-Class Model

What Shipped on June 9, 2026

This is the first time Anthropic has handed the public a model from its top "Mythos" tier, the class previously reserved for cyber-defense partners and a small number of biology researchers. Anthropic describes Fable 5's capabilities as exceeding those of any model it has ever made generally available, and as state-of-the-art on nearly all tested benchmarks, with the longest and most complex tasks showing its largest lead.

The headline facts a builder needs:

• API model ID: claude-fable-5
• Context window: 1,000,000 tokens
• Maximum output: up to 128,000 tokens
• Effort: adaptive reasoning only, with low / medium / high / xhigh levels; default high
• Surfaces: Claude API, claude.ai (Pro, Max, Team, Enterprise), Claude Code, Claude Managed Agents, Amazon Bedrock, Google Vertex AI, Microsoft Foundry
• Data retention: 30-day retention required on all Mythos-class traffic for safety monitoring; not used for training

What Anthropic's own customers reported

Anthropic's announcement included early-access quotes that are usable because they come from the primary source. Stripe reported that Fable 5 compressed months of engineering into days, performing a codebase-wide migration in a 50-million-line Ruby codebase in a single day that would otherwise have taken a team over two months. Cursor called it state-of-the-art on its CursorBench eval, opening up a class of long-horizon problems that were out of reach for earlier models. GitHub described it taking on complex, long-horizon coding tasks with autonomy and reliability exceeding previous benchmarks.

A Tier Above Opus

The naming trips people up, so anchor it once. Mythos is the tier. Mythos 5 is the raw configuration of the model, restricted to Project Glasswing and a forthcoming trusted-access program. Fable 5 is that same model wrapped in production safeguards so it can be offered to everyone. Anthropic's family now reads, from smallest to largest: Haiku, Sonnet, Opus, Mythos.

What "a tier above Opus" means in practice is not a few points on a leaderboard. It is sustained, autonomous work. Anthropic positions Fable 5 for the tasks that were previously too long, too ambiguous, or too multi-step for a model to finish on its own: large code migrations, multi-stage analysis, research projects, and document-heavy reasoning over tables, diagrams, and PDFs. Run it in an agent harness like Claude Code and it can plan across stages, delegate to subagents, and check its own work for hours at a stretch.

Who This Is For

The Effort Dial

Fable 5 uses adaptive reasoning: it decides whether and how much to think on each step based on task complexity. There is no fixed thinking budget to set and no extended-thinking toggle; those controls do not apply. The single most useful thing to internalize is that lower effort on Fable 5 still performs well, and often exceeds xhigh performance on prior models. Effort is a real lever on hard tasks, not a placebo: Anthropic and independent reviewers both report that the model converts thinking budget into accuracy on long-horizon coding.

How to choose effort

• xhigh — hard, long-horizon coding and agentic work. Set a large max_tokens (64k is a reasonable starting point) so the model has room to think and act across subagents and tool calls.
• high — the default; most intelligence-sensitive workloads.
• medium / low — routine work, or when you want a faster, more interactive working style. Reduce effort if a task completes but takes longer than necessary.

At higher effort, Fable 5 produces excellent verification behavior but can also gather context and deliberate beyond what a routine task needs — including unrequested tidying or refactoring. The fix is a short instruction, not a lower effort setting.

When you have enough information to act, act. Do not re-derive facts already established
in the conversation, re-litigate a decision the user has already made, or narrate
options you will not pursue in user-facing messages. If you are weighing a choice, give
a recommendation, not an exhaustive survey. This does not apply to thinking blocks.

Don't add features, refactor, or introduce abstractions beyond what the task requires. A
bug fix doesn't need surrounding cleanup and a one-shot operation usually doesn't need a
helper. Don't design for hypothetical future requirements: do the simplest thing that
works well. Avoid premature abstraction and half-finished implementations. Don't add
error handling, fallbacks, or validation for scenarios that cannot happen. Trust
internal code and framework guarantees. Only validate at system boundaries (user input,
external APIs). Don't use feature flags or backwards-compatibility shims when you can
just change the code.

Longer Turns by Default

A practical consequence reviewers have flagged: Fable 5 spends real time and output budget when it finishes, and when it times out the harness can still burn substantial context. Give long runs clear limits on time, steps, and tokens. The depth is worth the wait for work with real structure — types, APIs, query logic, caching — but plan for "more depth, not always a clean finish."

The second long-run risk is fabricated status. Deep into a session, any model can report progress it has not actually made. Anthropic's fix is an explicit progress-audit instruction, which in their testing nearly eliminated fabricated status reports even on tasks designed to elicit them.

Before reporting progress, audit each claim against a tool result from this session.
Only report work you can point to evidence for; if something is not yet verified, say so
explicitly. Report outcomes faithfully: if tests fail, say so with the output; if a step
was skipped, say that; when something is done and verified, state it plainly without
hedging.

Pause for the user only when the work genuinely requires them: a destructive or
irreversible action, a real scope change, or input that only they can provide. If you
hit one of these, ask and end the turn, rather than ending on a promise.

Strong Instruction Following

When un-steered, Fable 5 can elaborate beyond what a task needs, especially at higher effort: surveying options it will not pursue, explaining root causes at length, writing heavily structured PR descriptions, or narrating what the next line of code does. Two short instructions handle most of it — one for output brevity, one for what the model should and should not do on its own.

Lead with the outcome. Your first sentence after finishing should answer "what happened"
or "what did you find": the thing the user would ask for if they said "just give me the
TLDR." Supporting detail and reasoning come after. Being readable and being concise are
different things, and readability matters more.

The way to keep output short is to be selective about what you include (drop details
that don't change what the reader would do next), not to compress the writing into
fragments, abbreviations, arrow chains like A to B to fails, or jargon.

When the user is describing a problem, asking a question, or thinking out loud rather
than requesting a change, the deliverable is your assessment. Report your findings and
stop. Don't apply a fix until they ask for one. Before running a command that changes
system state (restarts, deletes, config edits), check that the evidence actually
supports that specific action. A signal that pattern-matches to a known failure may have
a different cause.

Patterns in claude.ai Chat

The strongest single chat habit, per Anthropic, is to start at the top of your difficulty range: pick a task harder than you would assign a prior model and have Fable 5 scope it, ask clarifying questions, and execute. The second habit is to state intent. Fable 5 performs better when it understands why you are asking.

I'm working on [the larger task] for [who it's for]. They need [what the output
enables]. With that in mind: [request].

I want to build [system]. It needs to [core requirement] and integrate with [constraint].
Before you write any code: scope this, list the decisions that change the architecture,
and ask me the questions you genuinely cannot answer from what I've given you. When you
have enough to act, act. Recommend a default for anything you'd otherwise survey.

Patterns in Cowork

Fable 5 follows instructions, stays in scope, and produces professional-grade output on financial analysis, spreadsheets, slides, and documents — the enterprise-workflow improvement Anthropic calls out by name. The pattern that works is to give it the whole corpus and the decision, not one file and one question.

Here are [N] documents. I need to decide [the decision]. Read across all of them, not
one at a time. Build the table of facts that bears on the decision, flag every conflict
between sources, and give me a recommendation with the two or three facts it hinges on.
If a document changes the answer, say which one and why.

When you write the summary at the end, drop the working shorthand. Write complete
sentences. Spell out terms. Don't use arrow chains, hyphen-stacked compounds, or labels
you made up earlier. When you mention files, commits, flags, or other identifiers, give
each one its own plain-language clause. Open with the outcome: one sentence on what
happened or what you found. Then the supporting detail. If you have to choose between
short and clear, choose clear.

Patterns in Claude Code

Anthropic's own example is the kind of task to bring: a codebase-wide migration. The model performs best when the task has real structure and clear verification. Pair the migration prompt below with the progress-audit prompt (03) and the boundaries prompt (06) from earlier.

Migrate this codebase from [old] to [new]. Work end to end: plan the migration in
stages, execute each stage, and run the test suite after each one. Don't ask permission
for reversible steps that follow from this request. Pause only for a destructive or
irreversible action, a real scope change, or input only I can provide. Before reporting
any stage complete, audit the claim against the actual test output and paste it.

You are operating autonomously. The user is not watching in real time and cannot answer
questions mid-task, so asking "Want me to..?" or "Shall I..?" will block the work. For
reversible actions that follow from the original request, proceed without asking.
Offering follow-ups after the task is done is fine; asking permission after already
discussing with the user before doing the work is not. Before ending your turn, check
your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or
a promise about work you have not done ("I'll..", "let me know when.."), do that work now
with tool calls. End your turn only when the task is complete or you are blocked on
input only the user can provide.

You have ample context remaining. Do not stop, summarize, or suggest a new session on
account of context limits. Continue the work.

Subagents and Memory

Long-lived subagents that keep context across subtasks save time and cost through cache reads and avoid bottlenecking on the slowest subagent. For memory, the mechanism can be as simple as a Markdown file: one lesson per file, a one-line summary at the top, corrections and confirmed approaches alike.

Delegate independent subtasks to subagents and keep working while they run. Intervene
if a subagent goes off track or is missing relevant context.

Store one lesson per file with a one-line summary at the top. Record corrections and
confirmed approaches alike, including why they mattered. Don't save what the repo or
chat history already records; update an existing note rather than creating a duplicate;
delete notes that turn out to be wrong.

Reflect on the previous sessions we've had together. Use subagents to identify core
themes and lessons, and store them in [X]. Make sure you know to reference [X] for
future use.

Vision and Long-Context

Anthropic's standout vision claim is rebuilding a web app's source code from screenshots alone, and playing Pokémon FireRed with a minimal vision-only harness where earlier models needed elaborate scaffolding. For long-context work, persistent file-based memory had an outsized effect: in Anthropic's Slay the Spire test, giving the model file memory improved performance three times more than it did for Opus 4.8.

Here is a screenshot of a UI. Rebuild it as [framework] source. Match layout, spacing,
type scale, and color from the image. Where the screenshot is ambiguous, crop in to
check rather than guessing. Output the component and a short note listing anything you
had to infer.

This task spans a large amount of context. Keep a running notes file: record the
decisions you've made, the facts you've confirmed, and the dead ends you've ruled out.
Reference it before each new stage so you don't re-derive what you already know. Update
it as you learn; remove notes that turn out to be wrong.

Safeguards and the Opus 4.8 Fallback

This is a design feature, not a bug, and it has direct engineering consequences. A fallback is a far better experience than an outright refusal, and you are not charged Fable prices for a request that falls back. But on the API, a flagged request can also return stop_reason: "refusal" — so production systems should configure server-side or client-side fallback to Opus 4.8 to handle those cleanly. Anthropic notes that benign cybersecurity and beneficial life-sciences work may also trip the classifiers; the safeguards are deliberately tuned conservatively at launch, with false positives expected to narrow over time.

A separate change affects business data: Fable 5, Mythos 5, and future models at this capability level require 30-day data retention on all traffic for safety monitoring. Anthropic states this data is not used to train models and is deleted after 30 days in almost all cases. Factor this into any data-handling review before adopting Fable 5 for regulated work.

Pricing Reality

The cost story is less about the prompt and more about the architecture around it: where you call the model, how you cache, and how you route work. The 90% caching discount means a reused system prompt or document is billed at one tenth the rate on cache hits — on a 200K-token input, a $2.00 input cost can drop toward $0.20. Disciplined model routing (send routine work to a smaller model, reserve Fable for the hard tasks) is the other major lever.

Subscription packaging — a dated fact, read carefully

On the Claude API and consumption-based Enterprise plans, Fable 5 is fully available from launch. For subscriptions, the rollout is time-boxed: Fable 5 is included on Pro, Max, Team, and seat-based Enterprise plans at no extra cost from June 9 through June 22, 2026. From June 23, using it on a subscription plan draws on usage credits. Anthropic says it will restore Fable 5 as a standard inclusion once capacity allows. Because this is the kind of fact that changes, verify the current packaging on Anthropic's pricing page before relying on it.

Fable 5 vs Opus 4.8 vs Mythos 5

Common Mistakes

• Underselling it on easy work. Teams that test Fable only on simple tasks miss its range. Bring your hardest unsolved problem.
• Prior-model timeouts. Hard requests run for minutes; autonomous runs for hours. Old timeouts will kill good runs mid-flight.
• Over-instructing. One brief instruction now steers most behavior. Long enumerated rule lists are wasted effort and can fight the model.
• Paying full price on repeated context. Skipping prompt caching leaves the single biggest cost lever on the table.
• No fallback wired. A flagged request can return a refusal stop reason. Without an Opus 4.8 fallback, that surfaces as a hard failure to your users.
• Keeping old "show your reasoning" instructions. Fable uses adaptive reasoning and summarized-only thinking output; stale instructions to expose chain-of-thought no longer apply.

Frequently Asked Questions