📖 Prompting Claude Fable 5

Fable 5 and Mythos 5 launched on Jun 9, 2026; U.S. government export controls on Jun 12 led Anthropic to suspend access for everyone; global access returned on Jul 1, 2026.

Understanding the context helps you avoid thinking the model “disappeared” because it was too dangerous — and helps set realistic expectations.

Claude Fable 5; Claude Mythos 5; export controls; Project Glasswing.

Amazon researchers reported a way to bypass Fable 5’s safeguards. But Anthropic’s own test showed that much less capable models—Opus 4.8, GPT-5.5, Kimi K2.7, even Haiku 4.5 and Sonnet 4.6—generated the SAME exploit demonstration.

Context over drama—the suspension was a regulatory precaution, not a failure unique to Fable 5.

Software vulnerability; comparative test between models; regulatory precaution.

Fable 5 is included in up to 50% of the weekly usage limit through 7/jul/2026 for Pro/Max/Team/some Enterprise plans; after that, via usage credits.

Knowing the limit helps avoid cost or quota surprises in the first week of use.

Weekly usage limit; usage credits; Claude Platform, Claude.ai, Claude Code, Claude Cowork.

Same capabilities as Fable 5, but without the safety classifiers — restricted use only through Project Glasswing, for defensive cybersecurity.

Keeps you from confusing the two models and their very different use cases.

Project Glasswing; safety classifiers; defensive cybersecurity.

Fable 5's global rollout is the right time to learn how to prompt a model that behaves differently from Opus 4.8.

Anyone who learns the right techniques from the start avoids months of trial and error.

Adoption window; learning curve; changes to prompting habits.

Dan Shipper (Every) gave Fable 5 a 91/100 on the internal “Senior Engineer” benchmark, compared with 63 for Opus 4.8. Boris Cherny (Anthropic) publicly called it “the best model I’ve ever used for code, by a wide margin.”

Signals the size of the capability jump—even though it’s a third-party account, not an official Anthropic fact.

“Senior Engineer” benchmark; early adopter account; “warp drive for coding.”

Intent context—saying WHAT the thing you’re asking for is FOR, not just WHAT to do.

It’s established prompt engineering practice (the video already makes this case)—it helps the model make the right micro-decisions on its own.

Task intent; purpose context; general practice, not a verbatim official quote from the Fable 5 doc.

Asking Claude to reproduce its internal reasoning in the response may trigger the reasoning_extraction refusal category, specific to Fable 5.

Old skills and system prompts that ask you to "show your reasoning" now trigger refusals and fallback to Opus 4.8.

stop_reason: "refusal"; reasoning_extraction; adaptive thinking.

The official documentation recommends auditing older skills for “echo/transcribe/explain” instructions about internal reasoning.

Migrating from Opus to Fable 5 without this audit increases refusals for no apparent reason to anyone who doesn’t know the trigger.

Harness instructions; structured thinking blocks; system prompt audit.

If the application needs visibility into reasoning, the right approach is to read the structured "adaptive thinking" blocks — not to request it in the response text.

Meets the need for transparency without triggering a reasoning_extraction refusal.

Adaptive thinking; structured blocks; reasoning visibility.

Examples of how to tie the “why” to a technical prompt—for example, “I’m reviewing this for production” vs. “It’s just a draft.”

The same technical request leads to very different behavior depending on the stated reason.

Task prompt; context signaling; conditional behavior.

Older instructions asking it to "explain your step-by-step process" were normal with Opus and break in Fable 5.

Finding this pattern helps avoid a silent fallback to Opus 4.8 and unexplained extra costs.

Legacy skills; silent fallback; prompt review.

Explicitly say what the model must NOT do, not just what it should do.

At high effort, Fable 5 may gather context and deliberate beyond what the task requires — negative prompting keeps this in check.

Negative prompting; over-engineering; overplanning.

The official text says not to add features/refactors/abstractions beyond the scope, not to clean up code around a bug fix, and not to create a helper for a one-off operation.

It’s the most direct official quote against unrequested "tidying."

Anti-tidying; premature abstraction; validation only at system boundaries.

The same official prompt covers not designing for hypothetical future requirements — just doing the simplest thing that works well.

Fable 5 tends to be more thorough by default; constraining it saves tokens and review time.

Deliberate simplicity; feature flags; backward-compatibility shims.

When the user is describing a problem or thinking aloud, the deliverable is the assessment—report and stop, don't apply a fix without asking.

Keeps you from changing system state (restart, delete, config) without evidence that truly supports the action.

Deliverable = assessment; destructive/irreversible action; confirmation before acting.

The negative prompting block works well pasted into CLAUDE.md, the system prompt, or the beginning of a session.

Pasting it once addresses the tendency to "tidy up" in every subsequent task in that project.

CLAUDE.md; system prompt; session/project scope.

After pasting the prompt, observe whether bug fix tasks start coming through without extra refactoring in subsequent sessions.

Closes the loop of “I tested and confirmed,” not just “I think it helped.”

Empirical verification; before-and-after comparison; scope of the delivered change.

The official prompt says to pause for the user only when the task truly requires it—a destructive or irreversible action, a real change in scope, or input only they can provide.

Eliminates the habit of “asking too many questions” that stalls the autonomous loop on tasks that already had enough information.

Anti-overplanning; irreversible action; end of turn.

If one of the cases that requires the user comes up, the right thing is to ask and end the turn there — never end by "promising" to do it later.

Eliminates “early stopping” without action — rare, but reported in long sessions.

End of turn; promise vs. action; rare early stopping.

Before reporting progress, audit every claim against a tool result from this session; report only what you can point to evidence for.

In Anthropic’s test, this nearly eliminated reports of fabricated status updates, even in tasks designed to induce them.

Evidence from tool results; accurate reporting; no hedging.

If a test fails, report the output; if a step was skipped, say so; when something is ready and verified, state it plainly.

It’s the opposite of the "pretty status report" the prompt is trying to eliminate.

Reported failure with output; skipped step; claim without hedging.

For long tasks, a verifier subagent with fresh context checks the work against the specification at defined intervals.

Fresh-context verifiers tend to outperform self-criticism by the same agent that did the work.

Fresh-context verifier; check interval; specification as the reference.

Compare progress reports before and after pasting both prompts (act + prove) into multi-step tasks.

Closes the practical loop — pasting the prompt isn’t enough; you have to confirm the actual behavior change.

Before-and-after comparison; multi-step task; behavior confirmation.

Fable 5 follows instructions well enough that you can guide its behavior with a short sentence instead of listing every rule by name.

Prompts and giant system prompts become dead weight—the model already understands the intent with far less text.

Instruction-following; brief instruction; unnecessary enumeration.

The first sentence of the response should answer “what happened” or “what did you find”—the TLDR the user would ask for; details and reasoning come afterward.

It’s the most direct official quote on how to structure the final response for the reader.

Outcome-first; TLDR; supporting detail after the result.

The official prompt says to distinguish readability from concision: cut details that don’t change the reader’s next action, rather than compressing the writing into fragments or abbreviations.

Saving tokens by turning text into a telegram makes it harder to read; saving by selecting content does not.

Readability; content selection; text fragmentation.

After working for a long time without the user watching, the final summary should be a re-grounding — lead with the result and explain each identifier (file, commit, flag) as if it were new.

It’s the official prompt that keeps the user from getting lost when returning from a long, autonomous session.

Re-grounding; shorthand between tool calls; clarity over brevity.

Thinking aloud in brief between tool calls is normal—unlike the final summary, which needs to be complete for a reader who didn’t see any of that.

Keeps you from thinking that “being telegraphic all the time” is the right behavior for every interaction.

Intermediate thinking; final summary; reader audience.

Test the same request with and without the "say less" prompt and compare whether the answer became more direct without turning into an incomprehensible fragment.

Closes the loop — “say less” doesn’t mean “be less clear.”

Clarity over brevity; response comparison; personal calibration.

max, xhigh, high (default), medium, and low—each with an official use case, from “deeper reasoning” to “simple tasks, e.g., subagents.”

Choosing the right level saves tokens without sacrificing quality where it isn’t needed.

output_config.effort; max/xhigh/high/medium/low; behavior vs. token budget.

Official quote: at lower effort levels, Claude still thinks through sufficiently difficult problems, but thinks less than it would at a higher level for the same problem.

Debunks the myth that low effort always means weak responses.

Behavioral signal; token budget; sufficiently difficult problem.

The docs’ practical recommendation: low levels in Fable 5 still perform well—don’t assume “low effort = weak” just because that was true when switching from Opus.

Keeps you from setting “high”/“max” on everything out of old habit and needlessly doubling the cost.

Habit migration; cost vs. performance; subagents running on low.

This isn’t “routing” with a product name—it’s an HTTP 200 with stop_reason: "refusal" and a category in stop_details.category.

Treating it as a generic error (blind retry) is the wrong approach; treating it as a valid response with metadata is the right one.

HTTP 200; stop_reason; stop_details.category.

cyber, bio, frontier_llm, and reasoning_extraction — each with the official text describing what triggers that category.

Knowing the category guides the right prompt adjustment — e.g., reasoning_extraction is resolved by removing "show your reasoning."

cyber; bio; frontier_llm; reasoning_extraction.

A refusal before any output is not charged; a refusal mid-stream charges for the input and output already emitted. There are 3 ways to fall back to Opus 4.8: server-side, SDK middleware (BetaRefusalFallbackMiddleware), or a manual retry with "fallback credit".

Deciding on a fallback strategy prevents product disruption when a refusal occurs in production.

Refusal billing; BetaRefusalFallbackMiddleware; fallback credit.

Fable 5 dispatches parallel subagents more readily than previous models; the official prompt recommends delegating independent subtasks and continuing to work while they run.

Asynchronous communication between the orchestrator and subagent replaces "blocking waits" with true parallelism.

Parallel subagents; asynchronous communication; intervention if a subagent goes off track.

Subagents that maintain context across subtasks save time and cost through cache reads.

Reusing context across subtasks is cheaper than recreating everything from scratch with each call.

Long-lived subagent; cache reads; cost per subtask.

The official prompt recommends saving one lesson per file, with a one-line summary at the top, recording confirmed corrections and successes—and why they mattered.

Disorganized memory becomes noise; 1 lesson per file keeps everything searchable and updatable.

1 lesson per file; update an existing note; delete a note that turns out to be wrong.

The official bootstrap prompt asks you to reflect on previous sessions, use subagents to identify key themes and lessons, and save them to a specific destination that can be referenced in the future.

Start the memory system with a real signal instead of an empty note.

Bootstrap; identification subagents; future reference to the memory destination.

Gives the agent a tool whose input is shown to the user exactly as written, without ending the turn — useful for a partial deliverable, a progress update with specific numbers, or answering a question asked mid-loop.

For long-running/asynchronous agents, solves the problem of “the user gets no updates until the end.”

Input displayed verbatim; no end of turn; partial progress update.

Skills built for earlier models are often too prescriptive and degrade Fable 5's quality; the recommendation is to review them and consider removing old instructions if the default performance is already better.

Closes the course loop — migrating isn’t just about learning a new technique; it’s also about getting the old prompt out of the way.

Overly prescriptive; default performance; skill review.