Claude Fable 5.2 & Mythos 5.2 Prompting Guide: 9 Rules That Fix Early Stops, Slow Replies and Runaway Costs

Quick Answer (TL;DR)
To prompt Claude Fable 5.2 or Claude Mythos 5.2 well, set the effort level on purpose, tell the model when work is truly finished, name exactly which actions need approval, say who owns the code, and delete old instructions that were written for earlier models.
Both models share the same underlying capability. The big prompting shifts are not about clever wording. They are about settings and boundaries: how much the model thinks, when it may stop, what it may do without asking, and how it reports back.
If you only have two minutes, do this:
1. Set effort to high explicitly, then test medium and xhigh on your own tasks. 2. Remove lines such as "answer without thinking." They no longer work at medium effort and above. Lower the effort instead. 3. Add a short "finish the work" block to agent prompts. 4. Replace vague caution ("never delete things") with specific, scoped rules ("ask before deleting files"). 5. Keep conversation history append-only, or your API calls can fail with a 400 error.
You can build and refine prompts like these with the ProCraft AI Prompt Studio, browse model-specific examples in the ProCraft Prompt Library, and compare the models themselves in the ProCraft AI Directory.
Key Facts at a Glance
Every fact comes from Anthropic's official documentation (see Sources at the end). The two models share the same underlying capability, the same 1M-token context window, the same 128k-token max output, the same adaptive always-on thinking, the same effort levels (low, medium, high, xhigh, max), the same default effort on the API (high), the same pricing (input $8 per million tokens, output $40 per million tokens, batch $4 in / $20 out per million, fast mode $16 in / $80 out per million) and the same 30-day data retention (not available under zero data retention unless Anthropic authorizes it).
The differences are access, not capability. The API model ID is claude-fable-5-2 for Fable and claude-mythos-5-2 for Mythos. Fable is open to all Claude API customers. Mythos is limited to organizations verified through Anthropic programs (for example the Cyber Verification Program).
For comparison, the earlier 5.1 generation cost $10 per million input tokens and $50 per million output tokens, so 5.2 is cheaper per token.
You can read a short profile of the Claude family in the ProCraft AI Directory entry for Claude.
What Are Claude Fable 5.2 and Claude Mythos 5.2?
Claude Fable 5.2 is Anthropic's model for demanding reasoning and long-running agentic work. Claude Mythos 5.2 offers the same capabilities, but only to organizations that Anthropic has verified.
The difference between them is access and safeguards, not intelligence. Fable runs safety classifiers that can decline requests in sensitive areas such as cyber harm and biological harm. Legitimate security and life-science teams can apply for verification and then use Mythos for approved work.
Why does this matter for prompting? Because a prompt that works on one works on the other. You do not need two prompt libraries. You need one good prompt system and an awareness of which refusals you may meet.
Anthropic itself suggests that most teams should start with the latest Opus model and move to Fable 5.2 only when their tests at higher Opus effort still fall short. That is useful advice if you are watching your budget: a stronger model is not automatically the better choice.
Why Prompting These Models Feels Different
Earlier prompting habits were built around models that needed coaxing: longer instructions, forceful capital letters, repeated reminders, and rules like "think step by step."
Fable 5.2 and Mythos 5.2 behave differently in three ways that matter:
Key Points
- They think almost every time. At high effort and above, they reason before nearly every reply, even a simple greeting.
- They follow instructions closely. A rule written as "never" is treated as absolute. A style limit is applied literally.
- They can stop early on long jobs, especially at lower effort.
So the prompting skill shifts from persuading the model to configuring it. Think of it as setting up a capable colleague: give them the right workload, clear authority, and a clean desk.
Rule 1: Set Effort on Purpose
Effort controls how much the model thinks, how many tool calls it makes, how long a turn takes and how many tokens it spends. It is the single most important dial.
Anthropic's guidance, in plain words:
Key Points
- Low is best for quick back-and-forth, well-specified tasks, high-volume work and fast subagents. Watch out: it is more likely to stop early on long tasks.
- Medium is best for interactive coding, chat and everyday knowledge work. Watch out: add finishing instructions for agents.
- High (the default) is best for hard coding, research, agentic work and long unattended runs. Watch out: turns are noticeably slower than medium.
- Xhigh is best for your hardest long-running work, only where you measured a gain. Watch out: many more tokens for a small score gain.
- Max is best for measuring the model's ceiling, and for open-ended math or science. Watch out: slow and very token-heavy.
Most of the capability gain is already present at high. The jump from medium to high improved results on most of the coding and knowledge-work tests Anthropic tracks, while above high the gains are uneven and depend on the task.
The "think less" trap
If you have an old prompt that says "answer directly without deliberating," remove it. In Anthropic's testing, that kind of line did not stop Fable 5.2 from thinking at medium effort and above. The only reliable way to get faster, cheaper answers is to lower the effort level for those turns.
Effort does not control length
Effort has little effect on how long the reply is. If you want shorter or friendlier answers, say so in the prompt. Use effort for thinking depth and the prompt for tone and length.
Mix levels in one workflow
A smart pattern is to plan at medium, then raise effort for the long unattended part. On the Claude API, a beta feature called per-message effort lets you change levels mid-conversation while keeping the prompt cache. Without it, changing the top-level effort can invalidate cached messages.
Your 30-minute effort test
1. Pick 10 real tasks from your own work. 2. Run them at medium, high and xhigh with the same prompt. 3. Score each run on correctness, completeness, time and token cost. 4. Choose the lowest level that meets your quality bar.
Do not copy a setting from Fable 5.1 or Opus 5.5. Anthropic notes that the amount of thinking at each level differs across models, so rerun your sweep.

Rule 2: Make the Model Finish the Whole Task
On long, multi-step jobs, Fable 5.2 sometimes ends its turn too soon. It may list what is left, offer to continue, or stop at an ordinary obstacle such as a timeout. This is more common at low and medium effort.
A finishing block you can adapt
Here is a ProCraft-style paraphrase of the idea. Adjust it to your product:
What the testing showed
Anthropic replayed recorded coding sessions at medium effort with a version of this text. About half as many sessions ended with unfinished work that could have continued, and output tokens rose by about 30 percent. It removed most endings that asked permission or offered to continue, but not endings that listed what remained and then stopped.
Two lessons follow. First, this block is a tool, not magic. Second, because the model now asks less often, you must keep your own confirmation step for anything risky or irreversible.

Rule 3: Write Approval Rules Like a Contract
Vague approval rules make agents timid. Anthropic tested a rule that listed "sending messages to people outside this conversation" as needing approval. In simulated tasks where nobody was available to approve, the model held back about half of its routine requests to colleagues and other teams.
Better approval rules
Key Points
- Name the action precisely. "Ask before deleting files" beats "be careful with changes."
- Put the exception inside the rule. "Ask before sending external email, except status updates to the project channel."
- List what is pre-approved. "You may read any file in /docs, run tests, and open draft pull requests without asking."
- Avoid absolute words unless you mean them. The model treats "never" as unbreakable.
When you say "continue"
If you are replying to an agent that paused for approval, be specific. "Yes, run the migration on the staging database" works far better than "go" or a thumbs-up, because the model can see exactly what you authorized.
Rule 4: Tell the Model Who Owns the Code
This is one of the most surprising findings. Fable 5.2 pays close attention to ownership. If your prompt says nothing, or presents the codebase as someone else's, the model tends to add to the existing structure, even when that duplicates code.
When the prompt said the codebase belonged to the model as long-term maintainer, it often consolidated duplicated code and sometimes made related fixes unasked. Anthropic measured consolidation in under 10 percent of runs without an ownership sentence and about 75 percent with one.
The trade-off
With the ownership sentence, output tokens rose by about 70 to 80 percent, and the model made extra changes, including new tests and documentation. In some runs it changed how an existing feature behaved. Final summaries sometimes left out small changes.
How to choose
Key Points
- For a minimal, surgical change in a codebase someone else owns: say the code belongs to the user and ask for the smallest change that works.
- For cleanup and consolidation: state that the model is the owner and long-term maintainer, and that design decisions are its call.
A scope rule alone does not cancel ownership. Even with "no drive-by refactors" earlier in the prompt, the model still consolidated code in more than half of runs when it was told it owned the codebase. So choose one framing, not both.
Always review the actual diff, not just the model's summary.
Rule 5: Keep Users Informed During Long Runs
On long agentic turns, Fable 5.2 can go quiet. It may even start its first tool call without saying what it is about to do.
Check your client first
The model's between-tool updates arrive as progress-update thinking blocks. At the default display setting, their text is empty, so a client that only renders text blocks looks silent. Setting the thinking display option to "updates" or "summarized" (beta) fixes that if you then render the non-empty blocks.
Prompt-level fixes
Where a human is in the loop, three options help:
1. Signal intent. Ask for one line before starting, brief updates while working, and a standalone recap at the end. Anthropic saw the model write an opening message in every test run, with output tokens per task up about 20 percent. 2. Harness reminder. Count consecutive tool calls with nothing readable. After several, append a short turn-scoped reminder asking for a quick status line. This roughly halved the longest silent stretch in testing. 3. One-line habit. Where mid-conversation system messages are unavailable, ask for a one-line update every few tool calls.
If nobody is watching, skip all this. Fable 5.2 is described as strong for long asynchronous work where frequent updates are not needed.
Rule 6: Set Expectations for Subagents
How much the model delegates depends on your harness. With a minimal subagent tool on short tasks, it rarely delegated. Inside a coding product whose prompts invite delegation, it delegated readily. At xhigh and max, it even used subagents to review its own work.
Why it matters
Subagents can be a large part of a session's cost. Before blaming the model, read your system prompt, skills and agent files for lines that tell it to delegate.
How to rein it in
Write a better subagent tool description that:
Key Points
- states what a subagent adds to the cost of the session,
- says when delegation is worth it and when it is not,
- tells the model how to brief a subagent properly.
In Anthropic's test at high effort, a longer cost-focused description roughly halved the number of subagents versus a short one. Only change the description if you actually see over-delegation.
Early testers also used Fable 5.2 as a planner and orchestrator for other models, which is a sensible way to put a premium model where it counts.
Rule 7: Stop Caution From Piling Up
Agent systems collect cautious instructions over time. A memory note says "never retry." A rule says "stop at the first error." Another says "always ask before external actions." A closely obedient model follows all of them, and work slows to a crawl.
Cleanup checklist
Key Points
- Delete stale notes that no longer apply, including notes the model wrote itself.
- Name approval-free steps explicitly instead of saying "act freely."
- Narrow stopping conditions such as "review at the first error."
- Scope every absolute. Replace "never delete files" with "ask for approval before deleting files."
- Restart stuck systems with trimmed memory when the buildup is severe.
Keep human confirmation for risky or irreversible actions. Cleaning up caution is not the same as removing safety.
Rule 8: Audit Prompts Written for Older Models
Some instructions that helped earlier models now cost money or cause side effects. Review these first:
Key Points
- "Delegate to subagents whenever possible" — remove it if the model over-delegates.
- Showing the model a token budget in the prompt — test without it; in testing at high and xhigh, removing a large budget lowered cost with equivalent performance.
- Harness code that edits earlier messages — keep history append-only to avoid 400 errors and wasted re-thinking.
- "Treat the last answer as done" lines — test carefully; they reduced thinking on follow-ups and made the model less likely to flag its own earlier mistakes.
- "Answer without deliberating" — remove it and lower effort instead.
- Hard sentence limits ("20 words max") — soften them; the model obeys literally, and prose gets choppy.
- Piles of old memory rules — trim and rewrite with scope and reason.
Make these edits in new conversations only. On Fable 5.2 and Mythos 5.2, changing the system prompt, tools or earlier messages in a stored conversation can fail the API's prefix check and return a 400 error. To change instructions mid-conversation, put them in the newest turn, or use mid-conversation system messages where available.
Rule 9: Make Final Reports Readable Without Context
After a long run, the person reading the final report usually did not see the tool calls or files behind it. The report must stand alone.
A paraphrased reporting block you can adapt:
Anthropic's testing showed this style made final reports less dense and cut semicolons. If your readers want more or less detail, add length instructions. And remember: style rules are followed closely, so avoid hard limits that make the writing robotic.
Understanding Refusals (and What They Are Not)
Fable 5.2 runs safety classifiers. A declined request returns a normal response with stop_reason: "refusal", and a category such as:
Key Points
cyber: possible cyber harm, such as malware or exploit developmentbio: possible biological harmfrontier_llm: help that could advance competing AI modelsreasoning_extraction: asking the model to write out its internal reasoning in the replygeneral_harms: another usage-policy areanull: no named category
What to do
1. Always check `stop_reason`. A refusal is a valid response, not a crash. 2. Remove "show your reasoning" instructions. To inspect how the model thought, use the summarized thinking display instead of asking for reasoning in the reply text. 3. Plan a fallback. Server-side fallback (beta) can retry a declined request on a recommended model. For Fable 5.2, permitted fallback targets are Claude Opus 4.8 and Claude Opus 5. Some categories, such as reasoning_extraction, have no fallback. 4. Apply for verification if your work is legitimate. Benign security or life-science work can trigger the classifiers. The Cyber Verification Program and Life Sciences Verification Program exist for exactly this reason, and Mythos 5.2 is the path for verified organizations.
Never try to bypass a refusal. Treat it as a routing signal.
Use the CRAFT Framework With Fable 5.2
ProCraft teaches a five-part prompting method called CRAFT: Context, Role, Action, Format, Tone. It maps neatly onto what these models need. You can practice it hands-on in the AI Prompt Studio and read the framework breakdown in the ProCraft blog guide to the Prompt Studio.
Here is how each letter changes for a modern agentic model:
Key Points
- Context (background and audience) — extra step for Fable / Mythos 5.2: add who owns the work, what is already approved, and what is deliberately off limits.
- Role (expert persona) — extra step: keep it short; the model already reasons deeply, so spend words on authority and boundaries.
- Action (exact task) — extra step: state the finish line so the model knows when it is truly done.
- Format (structure and length) — extra step: request a self-contained final report; set length in the prompt, not through effort.
- Tone (voice and mood) — extra step: ask for plain, direct language and avoid rigid word-count rules.
Template 1: Research task (medium or high effort)
Template 2: Coding task with clear ownership
Template 3: Long unattended agent run
For more starting points, search the ProCraft Prompt Library for Claude, ChatGPT and Gemini prompts, or open the Claude-filtered prompt results directly. These templates are starting points. Run them against your own tasks before you rely on them.
API Setup: A Safe Starting Configuration
Here is a minimal Python call that follows the guidance above. Check Anthropic's current API reference for exact parameter names before shipping, because betas and field names change.
Hard rules for 5.2 requests
Key Points
- Do not send
thinking: {"type": "disabled"}or a manualbudget_tokens. Both return a 400 error. Leavethinkingout or use adaptive. - Do not force a tool with
tool_choiceset toanyor a named tool. It returns a 400 error. Keep automatic tool choice, and use strict tool use or JSON outputs for schema-valid results. - Do not edit history. Keep
systemandtoolsfixed and only append tomessages. Send each assistant turn back exactly as returned. - Use the computer use toolset. The older
computer_20251124tool returns an error on every platform except Amazon Bedrock. Usecomputer_toolset_20260801. - Pair advisors correctly. A 5.2 executor needs a Fable 5.2 or Mythos 5.2 advisor.
- Expect thinking blocks to be model-bound. Moving a conversation to a different model can lose its earlier reasoning.
Migrating from 5.1
1. Change the model ID (claude-fable-5-1 to claude-fable-5-2, or the Mythos equivalent). 2. Test whether your code edits history. 3. Check any router or fallback that switches models. 4. Move computer use to the toolset. 5. Update the advisor model. 6. Re-run your evals with an effort sweep that starts at high.
What Will It Cost? A Simple Calculator
Standard pricing is $8 per million input tokens and $40 per million output tokens. Suppose one agent run uses 40,000 input tokens and 10,000 output tokens.
Key Points
- Standard: input $0.32 + output $0.40 = $0.72 total.
- Batch (50% of standard): input $0.16 + output $0.20 = $0.36 total.
- Fast mode: input $0.64 + output $0.80 = $1.44 total.
This is an illustration, not a forecast. Real agent runs use many calls and extra tool output, and higher effort uses more tokens. Cache reads cost only $0.20 per million tokens, so a stable, append-only prompt prefix is also a cost saver.
Five ways to cut cost without losing quality
1. Use low or medium effort for simple turns. 2. Remove token-budget text from prompts and test the result. 3. Limit subagents with a cost-aware tool description. 4. Keep the prompt prefix stable so caching works. 5. Use batch processing for work that does not need an instant answer.

10 Common Mistakes (and Quick Fixes)
1. Leaving effort on autopilot. Fix: set it explicitly and test neighbors. 2. Writing "don't think" instructions. Fix: lower effort. 3. Stacking "never" rules. Fix: scope each rule and state the exception. 4. Ignoring ownership. Fix: choose "user owns it" for surgical changes, or "you own it" for cleanup. 5. Trusting the summary over the diff. Fix: review the real changes. 6. Using a silent client. Fix: render progress-update blocks. 7. Letting memory grow forever. Fix: audit notes on a schedule. 8. Editing history mid-conversation. Fix: append only. 9. Treating a refusal as an error. Fix: branch on stop_reason. 10. Upgrading without evals. Fix: run a before-and-after test on your own tasks.
Your 7-Day Rollout Plan
Day 1: Baseline. Pick 10 real tasks. Record current quality, time and cost.
Day 2: Switch and set effort. Change the model ID, set effort to high, rerun.
Day 3: Clean old prompts. Remove "think less," old delegation lines and stale memory notes.
Day 4: Add finishing and approval blocks. Add the finishing text for agents and rewrite approval rules.
Day 5: Fix reporting. Add the communication block and check that your client shows progress updates.
Day 6: Effort sweep. Run medium, high and xhigh. Choose the lowest passing level per task type.
Day 7: Review and document. Compare against Day 1. Save winning prompts as templates in your team library.
Which Tool for Which Job?
Key Points
- Ready-made prompts to adapt — start at the ProCraft Prompt Library.
- To write and sharpen your own prompt — start at the AI Prompt Studio.
- To compare AI tools and models — start at the AI Directory.
- New model guides and tutorials — start at the ProCraft Blog.
- To turn an image into a prompt — start at Image to Prompt.
- Prompting fundamentals behind these rules — read the ProCraft prompt engineering guide. (Added line — the file did not link this guide.)
Frequently Asked Questions
What is the difference between Claude Fable 5.2 and Claude Mythos 5.2?
They share the same capabilities. Fable 5.2 is available to all Claude API customers and runs safety classifiers in sensitive areas. Mythos 5.2 is limited to organizations verified through Anthropic's programs, such as the Cyber Verification Program, for approved specialized work.
What are the API model IDs?
Fable 5.2 is claude-fable-5-2 and Mythos 5.2 is claude-mythos-5-2.
Which effort level should I use?
Start at high, which is the API default, then test medium and xhigh on your own tasks. Use low or medium for simple or high-volume work, and reserve max for measuring the ceiling or rare tasks where time and tokens do not matter.
Why does Fable 5.2 still think when I tell it not to?
At medium effort and above, instructions to answer without deliberating did not stop the model from thinking in Anthropic's testing. Lower the effort level instead.
Why does my agent stop before the job is done?
This happens more at low and medium effort. Add a finishing block that tells the model to diagnose ordinary obstacles and continue, while still leaving deliberate blockers alone and keeping confirmation for risky actions.
How do I make Claude refactor instead of just adding code?
Say that the model is the owner and long-term maintainer of the codebase. Expect more tokens and extra changes, and review the diff. If you want minimal changes, frame the code as the user's and ask for the smallest fix.
What causes the 400 "bound to a different conversation" error?
A failed prefix check. It happens when the system prompt, tools or earlier messages change between requests while thinking blocks are being replayed. Keep history append-only and send assistant turns back exactly as returned.
Can I turn thinking off?
No. Adaptive thinking is always on, and disabling it or setting a manual budget returns a 400 error. Use the effort setting to control depth.
How much does it cost?
Standard pricing is $8 per million input tokens and $40 per million output tokens for both models. Batch processing is half that, and fast mode is $16 and $80. Cache reads are $0.20 per million tokens.
Does data retention apply?
Yes. Both models require 30-day data retention and are not available under zero data retention unless Anthropic expressly authorizes it, so check your compliance needs before migrating.
Do I need Mythos 5.2 for normal coding or writing?
Usually not. Fable 5.2 handles general work, and Anthropic suggests starting with the latest Opus model for most workloads. Mythos is for verified teams doing specialized security or life-science work.
Where can I find prompts to try these ideas?
Browse the ProCraft Prompt Library, build your own in the AI Prompt Studio, and compare tools in the AI Directory. More model guides are on the ProCraft Blog.
Final Takeaway
The best way to prompt Claude Fable 5.2 and Mythos 5.2 is to stop treating the prompt as a spell and start treating it as a work agreement. Choose the effort level. Define "done." List what needs approval. Say who owns the code. Remove old rules that no longer fit. Ask for reports that a busy reader can understand in seconds.
Then measure. Every number in this guide comes from Anthropic's own tests on its own tasks, and your tasks will differ. Run small evals, change one thing at a time, and keep what works.
Ready to put this into practice? Start in the ProCraft AI Prompt Studio, grab a starting point from the Prompt Library, explore tools in the AI Directory, and keep learning on the ProCraft Blog. Visit procraft.site any time for new prompts and model guides.
Sources
Key Points
Disclosure: Performance figures are Anthropic's reported results on its own tests. Templates are starting points and have not been independently benchmarked by ProCraft. Features marked beta may change.
Explore ProCraft
(Added block, same as the earlier admin blogs.) Start at ProCraft, browse the free prompt library, compare tools in the AI directory, build prompts in the AI prompt studio, and read the prompt engineering guide.
Explore More Tested Prompts & AI Workflows
Browse 6,800+ copy-ready AI prompts and 5,000+ curated AI tools on ProCraft.