Claude Fable 5 Prompting Guide: Migration Notes for Long Tasks, Agents, and High Effort

Anthropic has published a prompting guide for Claude Fable 5 and Claude Mythos 5. The document is not mainly about model capabilities. It tells developers that when migrating an existing Claude Opus 4.8 workflow to Fable 5, prompts, agent harnesses, timeout strategy, and safety fallback may all need updates.

Fable 5’s change can be summarized simply: it is better suited to long, complex, end-to-end tasks, but at high effort it may also spend more time planning, checking, and expanding context. To use it well, the key is not to copy old prompts unchanged, but to redesign task boundaries, verification methods, and long-task interaction.

Test with Harder Tasks First

Anthropic recommends not testing Fable 5 only on simple tasks. Its strengths show up more clearly in work that previously took a human hours, days, or even weeks, such as large code migrations, multi-stage analysis, complex agent flows, cross-document research, and high-precision visual understanding.

If you evaluate it only with short Q&A, simple summaries, or one-off small functions, it is easy to underestimate Fable 5. A better test is to take a type of task that older models struggled with and let the model complete the whole path from understanding and planning to execution and verification.

Good test tasks include:

having the model read a codebase and make cross-module changes;
having the model implement a feature from a target specification, add tests, and run checks;
asking an agent to handle a multi-day research or analysis flow;
having the model extract structured information from screenshots, tables, PDFs, and charts;
splitting independent tasks across multiple sub-agents, then having the main agent summarize the results.

Effort Is the Main Control Knob

In Fable 5, effort is the main parameter for controlling intelligence, latency, and cost. The official recommendation is to start most tasks at high, use xhigh for the most capability-sensitive workloads, and use medium or low for routine work.

One important point is that lower effort levels on Fable 5 may still outperform higher effort levels on older models. Migration does not require pushing every task to the maximum. A better strategy is:

use high for hard and high-value tasks;
use xhigh for the most critical complex reasoning or long tasks;
use medium or low for routine Q&A, light rewrites, and simple tool calls;
lower effort if the task completes but takes too long;
raise effort if output verification is weak or reasoning is not deep enough.

Higher effort brings stronger reasoning and self-checking, but the model may also gather more context, explain more, or do unnecessary cleanup. For coding tasks, it is best to limit scope explicitly in the prompt:

1

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. Do the simplest reliable implementation.

Long Tasks Need Timeout, Streaming, and Progress Changes

For difficult tasks, a single Fable 5 request may run for many minutes, and autonomous runs may last hours. This is one of the easiest migration issues to miss.

If your application was designed around short requests, check these first:

client and server timeout settings;
whether streaming is supported;
whether the UI can show progress;
whether the agent harness supports asynchronous checks;
whether scheduled polling is needed instead of blocking the whole time.

To prevent overplanning on ambiguous tasks, add a short constraint:

1

When you have enough information to act, act. Do not re-derive facts already established in the conversation, or re-litigate decisions the user has already made.

This kind of prompt is more effective than a long behavior checklist because Fable 5’s instruction following is stronger.

Ground Progress Reports in Real Evidence

In long-running agent work, a common issue is that the model may give a plausible status update without support from tool results. Anthropic recommends requiring the model to audit progress before reporting to the user.

You can use a constraint like this:

1

Before reporting progress, align each claim with a tool result from this session. Only report work supported by evidence; if something is not yet verified, say so explicitly. If tests fail, report the failure output; if a step was skipped, say that; when something is done and verified, state it plainly.

This matters for coding agents, data-processing agents, and long research tasks. Users do not need optimistic status. They need progress that is traceable and reviewable.

State the Boundaries Clearly

Fable 5 is more proactive and may take extra actions without being asked, such as drafting an email, creating a backup branch, or expanding the task scope. When migrating old prompts, make it clear when the model should only provide an assessment and when it may act.

For example:

1

When the user is describing a problem, asking a question, or thinking out loud without requesting a change, the deliverable is your assessment. Report your findings and stop; do not apply a fix. Before running a command that changes system state, first verify that the evidence supports that specific action.

This rule applies to customer support, operations, developer tools, and enterprise knowledge work. The more capable the model is, the more clearly permissions need to be defined.

Use Sub-Agents More Actively

The official documentation says Fable 5 is better than older models at dispatching and sustaining parallel sub-agents. For complex tasks, the main agent does not need to complete every step sequentially. A better pattern is to delegate independent subtasks, keep the main thread moving, and intervene if a sub-agent drifts off target.

Good subtasks for sub-agents include:

finding relevant implementations in different parts of a codebase;
independently verifying whether a fix satisfies the specification;
analyzing different documents or data sources;
comparing a frontend implementation visually against a target;
reviewing final output with fresh context.

For long tasks, Anthropic also recommends using independent verifier sub-agents rather than relying only on self-critique. You can tell the model:

1

As you build, establish a method for checking your own work every [X], and use sub-agents to verify your work against the specification.

This reduces the problem of the model merely convincing itself that it is right.

A Memory System Improves Long-Term Performance

Fable 5 works well in workflows with memory. The official recommendation is to give the model somewhere to record lessons, even if it is only a Markdown file. The key is to store reusable lessons, not copy chat history.

A simple rule is:

1

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

This is especially useful for maintaining codebases over time, long research projects, enterprise knowledge bases, and complex automation flows. Fable 5 is not only a one-time executor. It is better suited to accumulating context across tasks.

Do Not Ask the Model to Reproduce Internal Reasoning

When migrating to Fable 5, check old prompts, skills, and system instructions for requirements such as “show your thinking,” “repeat your reasoning,” or “explain internal reasoning.” The official documentation explicitly warns that these instructions may trigger the reasoning_extraction refusal category, causing more requests to fall back to Claude Opus 4.8.

If an application truly needs reasoning visibility, it should read structured thinking blocks instead of asking the model to output internal reasoning as normal response text. For long tasks where progress needs to be shown to the user, it is also better to create a tool such as send_to_user, allowing the agent to send messages that must be displayed verbatim without interrupting execution.

Watch Safety Classification and Fallback

Fable 5 runs safety classifiers for high-risk domains, including offensive cybersecurity techniques, biology and life sciences content, and requests to extract summarized model thinking. Even legitimate cybersecurity or life sciences work may trigger safeguards.

If a request is refused or routed, the API side needs server-side or client-side fallback to Claude Opus 4.8. In other words, migrating to Fable 5 is not just changing the model name. You should also recheck failure handling, stop_reason: "refusal", user messaging, and billing paths.

Final Replies to Users Need to Be Clearer

After long tool-use and agent workflows, the model may accumulate a lot of internal context, and the final summary can become shorthand that only the executor understands. Anthropic recommends adding a separate constraint for final response style: outcome first, then key supporting details, without dumping working abbreviations, arrow chains, or internal labels on the user.

You can write the final response requirement like this:

1

The final summary is for a reader who did not see the intermediate process. Start with what happened or what was completed, then provide necessary details. Use complete sentences. Do not use arrow chains, stacked hyphens, or temporary labels. If short and clear conflict, choose clear.

This matters for agent experiences in products. Users do not need to see every trace of model work. They need the outcome, evidence, risks, and next step.

What to Change First During Migration

If you already have a Claude agent or prompt system, check these items first when migrating to Fable 5:

test with harder, longer, more complete tasks;
reassess effort instead of defaulting every task to the highest setting;
adjust timeouts, streaming, and asynchronous task checks;
add progress auditing based on tool results for long tasks;
define when the model may act and when it should only report an assessment;
delegate independent verification to fresh-context sub-agents;
add a simple memory system for cross-task lessons;
remove old instructions that ask the model to reproduce internal reasoning;
configure Opus 4.8 fallback after Fable 5 refusals or routing;
rewrite final summary style so users can quickly understand the result.

Fable 5 prompting is not about writing longer rules. It is about designing workflows that fit a stronger model: harder tasks, clearer boundaries, more real verification, and more asynchronous interaction. Things that previously required many small constraints may often be controlled with shorter principles on Fable 5. But long tasks, permission boundaries, and safety fallback need more design at the harness level.

Source: Anthropic: Prompting Claude Fable 5