Prompting Claude Fable 5 — Behavioral Patterns and Scaffolding Guide

Source: raw/prompting-claude-fable-5.md — Anthropic platform docs, fetched 2026-06-12.

Official Anthropic guide covering the behavioral differences and scaffolding patterns specific to Claude Fable 5 and Claude Mythos 5. Fable 5 handles tasks that were previously too complex, long-running, or ambiguous for prior models, and the teams seeing the best outcomes apply it to their hardest unsolved problems — testing only on simple workloads undersells its range.

Key Takeaways

• Longer turns are expected. Hard tasks at higher effort settings can run for minutes or hours; adjust client timeouts and harness architecture before migrating.
• high effort is the new default. xhigh for capability-critical work; medium/low for routine tasks. Lower Fable 5 effort still beats xhigh Opus 4.8 on most tasks.
• Brief instructions now steer whole behaviors. A single brevity instruction replaces an enumerated list of patterns; same for checkpoint and progress-grounding behaviors.
• Safety classifiers gate cybersecurity and life sciences. Requests in those domains return stop_reason: "refusal" and should be routed to Opus 4.8 fallback.
• Existing skills may be too prescriptive. Prompts designed for prior models can actively degrade Fable 5 output; review and trim.
• Don’t ask the model to echo its reasoning. Show-your-thinking instructions trigger the reasoning_extraction refusal category. Use thinking blocks via the API instead.

Behavioral changes requiring prompt updates

Longer turns by default

Individual requests on hard tasks can run many minutes; autonomous runs can extend hours. Restructure harnesses to check results asynchronously (scheduled jobs) rather than blocking. Add this to prevent over-planning on ambiguous tasks:

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.

Effort level selection

Setting	Use when
low / medium	Routine tasks, fast interactive turns
high	Default — most tasks
xhigh	Capability-critical workloads

To prevent unrequested refactoring or gold-plating at higher effort:

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.
Trust internal code and framework guarantees. Only validate at system boundaries.

Strong instruction following

Fable 5’s improved instruction-following means a single short directive replaces a long enumeration. To control verbosity and output structure:

Lead with the outcome. Your first sentence after finishing should answer "what happened"
or "what did you find." Supporting detail and reasoning come after. Readability matters
more than brevity. Keep output short by being selective about what you include, not by
compressing into fragments or arrow chains.

To define when checkpoint pauses are appropriate:

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.

Grounding progress claims

On long autonomous runs, this instruction nearly eliminated fabricated status reports in Anthropic’s internal testing:

Before reporting progress, audit each claim against a tool result from this session.
Only report work you can point to evidence for. Report outcomes faithfully: if tests
fail, say so with the output; if a step was skipped, say that.

Stating the boundaries

Fable 5 occasionally takes unrequested actions (drafting emails, creating backup branches). Define explicit scope constraints:

When the user is describing a problem or thinking out loud, 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, check that the evidence supports
that specific action.

Early-stopping edge cases

Deep in a long session, Fable 5 can occasionally end a turn with a statement of intent without executing it. For fully autonomous pipelines, add this system reminder:

You are operating autonomously. The user is not watching in real time. For reversible
actions that follow from the original request, proceed without asking. Before ending
your turn, check your last paragraph. If it is a plan, an analysis, or a promise about
work you have not done ("I'll…"), do that work now with tool calls.

Context-budget concern

Avoid surfacing explicit remaining-token counts to the model. If your harness must show them:

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

Prompting patterns for better output

Give the reason, not only the request

Fable 5 uses intent context to pull in relevant information rather than inferring it. Especially useful for long-running agents:

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

Readability in agentic conversations

After many tool calls, Fable 5 can produce dense shorthand with references to thinking the user never saw. Add a communication-style instruction:

Terse shorthand is fine between tool calls. Your final summary is for a reader who
didn't see any of that. Open with the outcome: one sentence on what happened or what
you found. Write complete sentences. Spell out terms. Don't use arrow chains or labels
you made up while working. If you have to choose between short and clear, choose clear.

Memory system

Fable 5 performs particularly well when it can record and reference lessons from previous runs. Provide a writable Markdown file and add:

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.

Bootstrap from prior sessions with:

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.

Parallel subagents

Fable 5 dispatches parallel subagents more readily than prior models. Prefer async orchestrator-to-subagent communication over blocking. Long-lived subagents save cost through cache reads and avoid bottlenecking on the slowest one.

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

Send-to-user tool (agentic UIs)

For long asynchronous agents, define a tool that delivers messages to the user verbatim without ending the turn. Tool inputs are never summarized, so content arrives intact:

{
  "name": "send_to_user",
  "description": "Display a message directly to the user. Use this for progress updates, partial results, or content the user must see exactly as written before the task finishes.",
  "input_schema": {
    "type": "object",
    "properties": {
      "message": { "type": "string", "description": "The content to display to the user." }
    },
    "required": ["message"]
  }
}

Defining the tool alone is insufficient — pair it with elicitation language:

Between tool calls, when you have content the user must read verbatim (a partial
deliverable, a direct answer to their question), call the send_to_user tool.
Use send_to_user only for user-facing content, not narration or reasoning.

Scaffolding migration checklist

• Adjust client timeouts and streaming for multi-minute turns
• Restructure blocking harnesses to async / scheduled-job check-ins
• Move effort to high as default; add xhigh selectively
• Add progress-grounding instruction to long-run system prompts
• Add boundary-stating instruction to prevent scope creep
• Add autonomous-pipeline instruction for non-interactive runs
• Review existing skills for over-prescription and trim
• Audit skills for show-your-reasoning / echo-thinking instructions — remove them
• Configure Opus 4.8 fallback for stop_reason: "refusal" responses
• Implement send_to_user tool for agentic UIs that need mid-run messages
• Provision a Markdown memory file for long-horizon agents

Related

• Claude Fable 5 + Mythos 5 — Launch Overview
• 4.6)
• OpenAI GPT-5 Prompting Guide — Cross-Vendor Reference
• Canva AI 2.0 Case Study (Fable 5 in production)
• Dynamic Workflows in Claude Code

Try It

1. Pick your hardest current task and give it to Fable 5 at xhigh effort — paste the full specification in one turn, not drip-fed.
2. Add the progress-grounding instruction to any autonomous pipeline system prompt.
3. Audit existing Claude Code skills for show-your-reasoning or echo-thinking lines and remove them.
4. Add a memory Markdown file (lessons.md) to any long-horizon agent and include the memory system instruction.
5. For agentic UIs: implement send_to_user and pair it with the elicitation language in the system prompt.