Prompting Claude Fable 5: Behavioral Changes and Best Practices

A practical guide to Claude Fable 5's new behaviors, covering effort levels, instruction following, long-running tasks, memory systems, parallel subagents, and recommended scaffolding changes for developers and teams.

You've upgraded to Claude Fable 5 and something feels off. The model runs longer than expected, does more than you asked, or occasionally stops mid-task to ask questions it shouldn't need answered. You're not doing anything wrong. The model is genuinely more capable, and that capability comes with new behaviors that need some tuning.

The good news is that most of these behaviors are easy to address with short, clear instructions. You don't need to rewrite everything from scratch. You just need to know what changed and where to steer.

This guide covers the patterns that come up most often when teams migrate to Claude Fable 5 and Claude Mythos 5. If you're looking for API changes, pricing, or model availability, see the official model introduction page.

---

What's New in Claude Fable 5

Before jumping into prompting patterns, here's a quick overview of where Claude Fable 5 meaningfully outperforms Claude Opus 4.8:

Area	What Improved
Long-horizon tasks	Sustains productive output across multi-day runs
First-shot accuracy	Solves complex, well-specified problems in one pass
Vision	Handles dense screenshots, blurry images, and technical diagrams better
Code review	Higher bug-finding recall across codebases and repo history
Parallel subagents	More reliable at dispatching and managing multiple agents
Enterprise workflows	Stays in scope on financial, spreadsheet, and document tasks
Ambiguity handling	Determines next steps well from vague or multi-threaded requests

One important note: Claude Fable 5 has safety classifiers for offensive cybersecurity and biology/life sciences content. Requests in those areas may return a stop_reason: "refusal". Configure a fallback to Claude Opus 4.8 to handle those automatically.

---

Turns Run Longer Now

This is the change teams notice first. At higher effort settings, a single request can take many minutes. Autonomous runs can stretch for hours.

Before migrating, update your client timeouts, streaming setup, and any user-facing progress indicators. Where possible, restructure your harness to check on long runs asynchronously (for example, via scheduled jobs) instead of blocking until the task completes.

If the model is overplanning or narrating too much before acting, add this to your system prompt:

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.

---

Use Effort Levels Intentionally

Effort is your main lever for balancing speed, cost, and output quality on Claude Fable 5.

Effort Level	When to Use
low / medium	Routine, simple tasks
high	Most tasks (recommended default)
xhigh	Maximum capability for the hardest workloads

Even at medium, Claude Fable 5 often outperforms xhigh on prior models. If a task finishes correctly but takes longer than you need, drop the effort level.

At higher effort, the model may over-engineer. Use this prompt to keep it focused:

Don't add features, refactor, or introduce abstractions beyond what the task requires.
A bug fix doesn't need surrounding cleanup. Don't design for hypothetical future
requirements: do the simplest thing that works well. 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.

---

Instruction Following Is Much Stronger

Claude Fable 5 follows instructions well enough that you no longer need to enumerate every behavior individually. One clear directive covers a lot of ground.

For example, if the model is being too verbose, this single prompt handles it:

Lead with the outcome. Your first sentence after finishing should answer "what happened"
or "what did you find." Supporting detail comes after. The way to keep output short is
to be selective about what you include, not to compress into fragments, abbreviations,
or arrow chains like A -> B -> fails.

For checkpoint behavior in long workflows, one instruction replaces a whole list of rules:

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.

---

Ground Progress Reports in Tool Results

On long autonomous runs, the model can sometimes report progress on work that hasn't actually completed. Fix this with one instruction:

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.

This nearly eliminates fabricated status reports, even on tasks designed to elicit them.

---

Set Explicit Boundaries on Actions

Claude Fable 5 can occasionally take unrequested actions, like drafting an email that wasn't asked for or creating a git branch as a backup. Define what it should and shouldn't do:

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. Before running a command that changes system state
(restarts, deletes, config edits), check that the evidence actually supports that
specific action.

---

Use Parallel Subagents

Claude Fable 5 handles parallel subagents much better than prior models. You can delegate independent subtasks and let them run simultaneously instead of waiting for each to finish before starting the next.

Long-lived subagents that retain context across subtasks are especially efficient. They save time and cost through cache reads and avoid bottlenecking on the slowest subagent.

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

---

Build a Simple Memory System

Claude Fable 5 performs noticeably better when it can store and reference lessons from previous runs. A simple Markdown file works well for this.

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.

To bootstrap the memory system from past sessions:

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.

A simple memory directory might look like this:

memory/
  auth-fix-2024-06-01.md
  deployment-steps.md
  api-rate-limit-lesson.md

---

Handle Early Stopping in Long Sessions

Deep into a long session, the model can occasionally end its turn with a plan or statement of intent ("I'll now run X") without actually calling the tool. A "continue" or "go ahead" is usually enough.

For autonomous pipelines, add this to your system prompt:

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, a list of next steps, or a
promise about work you have not done ("I'll…"), 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.

---

Give Context, Not Just Instructions

The model uses intent to make better decisions. When you explain why you're asking, it connects the task to relevant information rather than inferring on its own. This matters most 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].

---

Add a Send-to-User Tool for Async Agents

When running long asynchronous agents, you sometimes need the model to surface a message to the user mid-task without ending its turn. Tool inputs are never summarized, so the content arrives exactly as written.

{
  "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"]
  }
}

Use this whenever your UX depends on delivering verbatim content or direct user interactions mid-task.

---

Recommended Scaffolding Changes

• Test on harder tasks. Claude Fable 5 is undersold when only tested on simple workloads. Start with something harder than you'd assign to a prior model.
• Use verifier subagents. Separate, fresh-context verifiers outperform self-critique. For long runs: Establish a method for checking your own work every [X interval], verifying with subagents against the specification.
• Trim older prompts. Skills written for prior models are often too prescriptive and can degrade output. Review existing instructions and remove anything where the default behavior is already better.
• Don't ask the model to echo its reasoning. Instructions like "show your thinking" or "explain your reasoning" can trigger the reasoning_extraction refusal on Claude Fable 5, causing fallbacks to Opus 4.8. Use structured thinking blocks from adaptive thinking instead.
• Add the send-to-user tool. For any long or async agent where message delivery matters, this tool is worth setting up.

---

Q&A

1. Do I need to rewrite all my existing prompts for Claude Fable 5?

Not necessarily. Start by testing your current prompts and only update where you notice problems. The model's stronger instruction following means small changes often have a large effect.

2. Why is my Claude Fable 5 response taking so long?

At higher effort settings, the model gathers context, builds, and verifies its work more thoroughly. If speed matters, try dropping to medium effort or adding an instruction to act once it has enough information.

3. What is the stop_reason: "refusal" and when does it happen?

Claude Fable 5 has safety classifiers for offensive cybersecurity and biology/life sciences content. Requests in those areas return a refusal stop reason. Configure a fallback to Claude Opus 4.8 to handle these automatically.

4. Can I still use skills and system prompts I built for Claude Opus 4.8?

Yes, but review them first. Older skills tend to be overly prescriptive, which can actually reduce output quality on Claude Fable 5. Remove instructions where the model's default behavior is already good.

5. How do I stop the model from doing things I didn't ask for?

Add explicit boundary instructions to your system prompt. Tell it clearly what counts as a deliverable versus a request for assessment, and require it to verify evidence before taking actions that change system state.

6. What is the best effort level to start with?

Use high as your default. Switch to xhigh only for your most demanding tasks, and use medium or low for routine or interactive work where speed matters more than depth.

7. How do I prevent fabricated progress reports during long autonomous runs?

Instruct the model to audit each claim against a tool result before reporting it. This single instruction significantly reduces false progress updates.

8. What is the send-to-user tool and do I need it?

It's a custom tool you define that lets the model surface a message to the user mid-task without ending its turn. You need it if your agent runs for a long time and users need updates or partial results delivered verbatim.

9. How does memory work with Claude Fable 5?

Claude has no persistent memory by default. You can create a simple file-based memory system (a folder of Markdown files) and instruct the model to write and read from it during sessions. This improves performance significantly on repeated or iterative tasks.

10. When should I use parallel subagents?

Whenever a task has independent subtasks that don't depend on each other's output. Rather than running them sequentially, dispatch them in parallel and let the orchestrator continue working while they run. Long-lived subagents with retained context are especially cost-effective.

My SaaS

Acluebox

Build modular and reusable system prompts with my SaaS,

Acluebox

. Also, free prompt template generators there.

References

• Prompting Claude Fable 5