How to prompt Claude Fable 5

What actually changed

Claude Fable 5 is Anthropic's most capable widely released model, built for problems that were previously too complex, long-running, or ambiguous for prior models: end-to-end work that takes a person hours, days, or weeks. Anthropic's own advice is to point it at your hardest unsolved problems, because testing it only on simple tasks undersells it. (Its limited-release sibling, Claude Mythos 5, shares the same capabilities; the refusal and safety behavior described below is specific to Fable 5.) For prompting, three shifts matter most:

On the “re-release.” Fable 5 launched in June 2026, was briefly suspended, and was restored on July 1, 2026 with a strengthened safety classifier that routes blocked requests to Claude Opus 4.8. That was an availability and safety event, not a retraining: the prompting guidance below is unchanged either way.

• Longer turns by default. A single hard request can run for many minutes at higher effort, and autonomous runs can go for hours. Raise client timeouts and progress indicators, and prefer checking on runs asynchronously over blocking.
• Stronger instruction following. You can steer most behavior with one brief instruction instead of enumerating every case by name. Long, prescriptive prompts written for older models can now degrade output.
• More initiative. It plans, verifies, delegates to subagents, and occasionally acts beyond what you asked. That is powerful, and it is exactly why setting boundaries becomes part of the prompt.

A capability jump like this is a good moment to re-read your existing prompts and skills and delete instructions the model no longer needs. This guide distills Anthropic's official Prompting Claude Fable 5 guidance into the patterns you will reach for most.

Effort is your main dial

On Fable 5, effort is the primary control for the trade-off between intelligence, latency, and cost. Use high as the default, xhigh for the most capability-sensitive work, and medium or low for routine tasks. A key surprise: Fable 5 at lower effort still performs well and often beats xhigh on prior models. If a task finishes correctly but takes longer than you want, or you want a quicker, more interactive feel, turn effort down.

Higher effort produces the most rigorous reasoning and verification, but on routine work it can also over-gather context and do unrequested tidying. When you want it to stay in its lane, say so once:

Don't add features, refactor, or introduce abstractions beyond what the task
requires. A bug fix doesn't need surrounding cleanup. Do the simplest thing that
works well; only validate at real system boundaries (user input, external APIs).

Say less, steer with intent

Because instruction following is so much better, a short instruction usually does the work of a long checklist. Two patterns pay off repeatedly. First, a single brevity instruction beats listing every verbose habit:

Lead with the outcome. Your first sentence should answer "what happened" or
"what did you find." Supporting detail comes after. Be selective about what you
include rather than compressing into fragments, arrow chains, or jargon.

Second, give the reason, not only the request. Context lets Fable 5 connect a task to the right information instead of guessing your intent, which matters most for long-running work drawing on several threads:

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

This is the same “name the audience, state the goal” discipline from good vs bad prompts, and it matters more here, not less, because the model is doing more on its own.

Keep long runs honest

The failure mode that bites hardest on long autonomous work is a confident status report for work that was never actually verified. Fable 5 responds well to being told to audit its claims against real evidence. In Anthropic's testing this nearly eliminated fabricated progress reports even on tasks designed to provoke 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. If tests fail, say so with the output; if a step was skipped,
say that.

Pair this with explicit self-verification: fresh-context verifier subagents tend to outperform self-critique, so for long builds, instruct it to check its work against the spec at a set interval as it goes.

State the boundaries

More initiative means you should be explicit about what counts as “done” and when to stop. Two boundaries are worth setting on almost every agentic task. The first separates assessment from action:

When the user is describing a problem 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.

The second defines when to pause for a human, so it stops only where it genuinely needs you rather than at every fork:

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

For fully autonomous pipelines where no one is watching, invert it: tell the model to proceed on reversible actions that follow from the original request, and to check its last paragraph before ending. If that paragraph is a plan, a question, or an “I'll now do X” promise, it should do the work with tool calls instead of ending the turn.

The migration gotcha: don't ask it to show its reasoning

This one is easy to miss and quietly expensive. Fable 5 runs safety classifiers, and one of them, reasoning extraction, fires when a prompt tells the model to echo, transcribe, or explain its internal reasoning as response text. That triggers a refusal and an elevated rate of fallback to Claude Opus 4.8, so a “show your work” line copied from an older prompt can silently downgrade your model. When migrating, audit skills and system prompts for reflect-and-explain instructions. If you need reasoning visibility, read the structured thinking blocks from adaptive thinking instead, and surface progress with a send-to-user tool.

Two related notes from the same guidance: Fable 5 also runs classifiers for offensive cybersecurity and life-sciences content, so configure a fallback to Opus 4.8 for legitimate work near those areas. And in very long sessions it can offer to summarize and hand off; that is usually triggered by a visible token countdown. Avoid surfacing exact context-budget numbers, and if you must, reassure it: You have ample context remaining. Continue the work.

A few API essentials that catch teams migrating older scaffolding:

• Adaptive thinking is always on. Control reasoning depth with effort, not a thinking budget; setting budget_tokens now returns an error.
• Only summarized thinking is returned, never raw chain-of-thought. Pass thinking blocks back unchanged across turns on the same model.
• Last-turn assistant prefill is not supported. Use structured outputs or tools to shape the response instead.

Let it delegate, and give it a memory

Fable 5 dispatches parallel subagents more readily and manages them reliably. Encourage delegation, and prefer asynchronous communication over blocking on each subagent's return. It also performs noticeably better when it can record and reuse lessons, which can be as simple as a Markdown file:

Delegate independent subtasks to subagents and keep working while they run.
Store one lesson per file with a one-line summary at the top; record corrections
and confirmed approaches alike, and why they mattered. Update an existing note
rather than duplicating, and delete notes that turn out to be wrong.

The through-line across all of this: Fable 5 rewards intent and boundaries over enumerated instructions. Tell it what you are trying to achieve, where the edges are, and how to prove its work, then get out of its way. When a prompt written for an older model underperforms, the fix is usually to remove instructions, not add them.