To prompt Claude Fable 5 well, front-load the full task, the reason behind it, and clear boundaries in one decisive turn, set the right effort level, and tell the model to verify its own work against evidence. Fable 5 is built for long, autonomous runs, so a clear brief up front beats a stream of mid-task corrections. You are paying for a few high-quality turns, not for supervision, so the discipline starts before the prompt: only route work here when it is genuinely hard, and then let the model run.
What is Claude Fable 5? Claude Fable 5 (
claude-fable-5) is Anthropic's most capable widely released model, built for the most demanding reasoning and long-horizon agentic work. It has a 1M token context window and produces up to 128K output tokens per request. Thinking is always on, the raw chain of thought is never returned, and depth is controlled with an effort dial rather than a thinking-token budget. Per Anthropic's model docs, it is priced above the Opus tier at $10 per million input tokens and $50 per million output tokens.
What makes Claude Fable 5 different from other Claude models?
Three facts shape how you prompt it, all from Anthropic's model documentation:
- It is the price ceiling. At $10 in and $50 out per million tokens, Fable 5 costs roughly double the Opus tier on both sides. Every token it reads and writes is the most expensive token in the Claude lineup, which is exactly why you select it on purpose, not by reflex.
- Thinking is always on. You do not set a thinking budget and you cannot disable thinking. You steer depth with the
effortparameter (lowthroughmax), and reasoning happens on every request. - Long turns are normal. Anthropic's guidance notes that a single hard request can run many minutes at higher effort while the model gathers context, builds, and checks its own work. This is a feature, not a stall. It is the model doing in one turn what a cheaper model would need you to shepherd across ten. Plan for streaming and asynchronous check-ins rather than blocking on one call.
Put those together and the method points one direction. The way to get value from a premium, autonomous model is to pay for few decisive turns, not for supervision. A supervised workflow, where you prompt, read, correct, and re-prompt, multiplies the expensive output tokens across every round trip. A decisive workflow front-loads everything the model needs and lets it finish. Same model, very different bill.
When should you use Claude Fable 5?
The default answer is: you should not. Most work you hand to an AI agent is short, well-defined, and easy to check. Summarizing a document, classifying a support ticket, extracting fields from an invoice, rewriting a paragraph: a smaller, faster model does these well, and paying frontier prices for them is waste. Reaching for the most capable model on every task is the most common and most expensive mistake operators make.
Fable 5 earns its cost on a specific profile of task. Anthropic's agent-design guidance frames the check as four gates. If the answer to any of them is no, drop to a cheaper model.
- Complexity. Is the task genuinely multi-step and hard to fully specify in advance? Turning a spec into a working system qualifies. Extracting a title from a PDF does not.
- Value. Does the outcome justify the premium price and the longer runtime?
- Viability. Is this a task type the model is actually good at?
- Cost of error. Can mistakes be caught and recovered, through tests, review, or rollback?
Read those as an AND, not an OR. A task that is long-horizon but low-value and unambiguous, say a nightly batch of routine transforms, does not need Fable 5. The strongest fits score high on all four:
| Task attribute | Route to Claude Fable 5 | Route to a smaller, faster model |
|---|---|---|
| Horizon | Long: many steps, planning, tool calls chained over time | Short: one call, one answer |
| Value | High: a wrong answer is costly, a right one is worth real money | Low: cheap to redo, low stakes |
| Ambiguity | High: the path is unclear and requires judgment | Low: the rules are explicit and mechanical |
| Verifiability | Self-verifiable: the model can test, run, or check its own output | Trivial or manual: a human eyeballs it anyway |
Why self-verifiability is the quiet requirement
Of the four, self-verifiability is the one people skip. Autonomy is only safe when the model can tell whether it succeeded. If a task has a built-in check (code that runs, a test that passes, a number that has to reconcile, a schema the output must match) then Fable 5 can iterate toward a correct result without you in the loop. If there is no way for the model to know it is right, autonomy just produces confident, unchecked output faster. Before you delegate, ask: how will the model know it is done and correct? If you cannot answer, either add a check or keep a human in the loop.
One rule from Anthropic's early-access notes: the teams with the best Fable 5 outcomes handed it their hardest unsolved problems first, then let it scope the problem, ask questions, and execute. Do not evaluate it only on work older models already handle well. Its biggest gains show up above that line.
How much does Claude Fable 5 cost?
Fable 5 sits at the top of the price ladder. Here is how it compares to the rest of the current Claude lineup, per Anthropic's model docs (prices per million tokens):
| Model | Input $/M | Output $/M | Reach for it when |
|---|---|---|---|
| Claude Fable 5 | $10.00 | $50.00 | The hardest reasoning and long-horizon autonomous work |
| Claude Opus 4.8 | $5.00 | $25.00 | Most capable Opus-tier work; the default upgrade |
| Claude Sonnet 5 | $3.00 | $15.00 | High-volume coding and agentic work at near-Opus quality |
| Claude Haiku 4.5 | $1.00 | $5.00 | Simple, speed-critical, high-volume tasks |
Output is where Fable 5 bites. At $50 per million output tokens, a verbose model that pads every answer with restated context, rejected alternatives, and narration you did not ask for is directly burning money. That is the first prompting lever: tell it to lead with the outcome and cut what the reader does not need. Anthropic's guidance is explicit that being readable and being concise are different goals, and that the way to keep output short is to be selective about what you include, not to compress everything into fragments.
The effort dial is your real cost control
Because thinking is always on, the effort parameter is how you tune the intelligence, latency, and cost tradeoff. Anthropic's docs describe the levels this way:
| Effort | Use it for | What to expect |
|---|---|---|
low | Routine or latency-sensitive work and subtasks | Still very strong on Fable 5, often beating the top settings of older models |
medium | Everyday work you want done cleanly | A favorable balance of cost and quality |
high | Most tasks (the default) | Balances token spend and depth |
xhigh | The most capability-sensitive coding and agentic work | Buys the most rigorous self-verification behavior |
max | Cases where correctness matters more than cost | Highest ceiling, but can overthink and show diminishing returns |
Here is the break-even insight most people miss. On Fable 5, lower effort settings still perform very well, often exceeding the xhigh or even max output of previous models, per Anthropic's guidance. So the reflex to crank effort to the ceiling is usually wrong. Start at high, sweep down to medium and low on routine work, and only reach for max when a mistake costs more than the extra tokens. Reduce effort when a task completes correctly but takes longer than it needs to. Raise it when you see shallow reasoning on a genuinely hard problem, rather than trying to prompt your way around it.
How do you prompt Claude Fable 5 for autonomy?
Once a task clears the gate, the craft is not clever phrasing. It is handing an autonomous worker a brief clear enough that it can run for an hour without you. Anthropic's migration guidance for Fable 5 distills into a handful of load-bearing principles:
- Give the full specification up front. State the task, the intent, and the constraints in the first turn. Well-specified initial prompts maximize autonomy and minimize expensive back-and-forth. Ambiguity revealed over many turns costs more and often performs worse.
- Give the reason, not just the request. Fable 5 connects a task to the right context when it understands intent. A pattern that works: "I am working on X for Y, who needs Z. With that in mind, here is the request."
- Define done explicitly. Write the acceptance criteria into the prompt. This is what the model verifies against, so vague criteria produce vague work.
- State the boundaries. Fable 5 sometimes takes unrequested but adjacent actions, like drafting an email or creating a backup branch. Tell it what not to do. When the user is thinking out loud rather than requesting a change, the deliverable is your assessment: report findings and stop.
- Ground every progress claim in evidence. On long runs, instruct it to audit each status claim against an actual tool result before reporting it. Anthropic's testing shows this nearly eliminates fabricated progress. If something is not verified, it should say so.
- Set the communication style. Tell it to lead with the outcome and drop working shorthand from its final summary. This protects your output-token bill and your readability at once.
- Let it delegate and remember. Fable 5 is dependable at running parallel sub-agents and at writing learnings to a memory file. Encourage both rather than suppressing them.
- Do not over-prescribe. Prompts and skills written for older, more step-by-step models often lower Fable 5's output quality. State the goal and the constraints, then get out of the way.
Notice the shape. Every principle is either front-loaded context, a done-criterion, a boundary, an evidence rule, or a verification rule. That is the whole discipline, and because it is structural rather than clever, it is reusable. A good Fable 5 prompt is not a one-off, it is a template with blanks for the task, the reason, the boundaries, the effort level, and the style. Fill the slots once and you have a decisive turn you can run again across builds.