Complete Guide to Claude Fable 5.1: Evolution, Token Saving, and Skill Construction

Evolution, Token Saving, Prompts, Harnesses, and Skill Construction

On September 1, 2026, Anthropic released "Claude Fable 5.1." As of September 2, 2026, when I am writing this article, it has only been one day since the release. Therefore, rather than subjective reviews on social media, I will organize this information based on Anthropic's official documentation, API documents, and the latest Claude Code specifications.

To give you the conclusion first: Fable 5.1 is not just a "model that answers normal questions slightly smarter."

Its essence lies in its ability to handle tasks spanning hours or days without losing sight of the objective, digging down to root causes rather than surface-level issues, and verifying its own output until the very end.

However, the price is twice that of Opus 5 and five times that of Sonnet 5. Furthermore, internal thinking cannot be turned off. If you throw everything at Fable 5.1, you will exhaust your usage limits and budget before you can truly leverage its capabilities.

The key to mastering Fable 5.1 is not just writing great prompts.

It is designing which specific tasks to assign to Fable, what information to load, and which processes to offload to cheaper models or scripts.

Part 1: Complete Explanation of Claude Fable 5.1

1. What is Claude Fable 5.1?

Claude Fable 5.1 is positioned as the highest-capability model among those Anthropic has released to the public.

Fable 5.1 and the invitation-only Claude Mythos 5.1 are essentially the same model. The difference lies primarily in safety measures. The publicly available Fable includes strong classifiers to detect high-risk areas such as cybersecurity, life sciences, and chemistry. Meanwhile, Mythos is used by vetted organizations for defensive research and other purposes. (Anthropic

Key specifications are as follows:

For individual Claude users, it is available to Pro, Max, Team, and Enterprise users. On the API, it is available to general customers without special screening. (Claude Platform

A 1-million-token context can, by simple calculation, handle several to a dozen books, massive codebases, or long-term conversation histories at once.

However, "it can fit 1 million tokens" is different from "you should put in 1 million tokens."

The more irrelevant files, old conversations, and long logs you stuff in, the more important information gets buried. While Fable 5.1 can handle massive contexts, it does not automatically neutralize irrelevant context for you.

2. The Evolution of Fable 5.1 is "Working Longer"

The most significant evolution of Fable 5.1 is not its single-shot accuracy, but its ability to maintain consistency during long-duration agent tasks.

General AI agents tend to cause the following problems as tasks get longer:

• Forgetting the initial objective.
• Performing only symptomatic fixes without investigating the cause.
• Reading the same files or web pages repeatedly.
• Arbitrarily scaling down the work midway.
• Declaring "I will test next" and then simply ending.
• Making massive changes but failing to perform a final operation check.

Fable 5.1 focuses heavily on improving these breakdowns during long-duration work. Official descriptions list coding, browser operations, research, and document/spreadsheet/slide creation spanning hours to multiple days as primary use cases. It is designed to recover from failed steps, re-prioritize, and proceed while maintaining its own work logs. (Anthropic

Early adopting companies have reported the following cases:

At MongoDB, it reportedly investigated service code and documentation to create a new design, completing a complex prototype in about three days through hours of autonomous execution. At Ramp, it operated for 38 consecutive hours on a machine learning problem, discovered labeling issues in past results, and executed six experiments in parallel after fixing them. (Anthropic

Furthermore, in a case from Millennium, it was reported that for a crash occurring only once in a million times, the model disassembled external libraries, cross-referenced them with core dumps, and reached a cause that had gone undiscovered for years. While these are customer stories on the official page and not results reproduced by independent agencies, they clearly represent the direction Fable 5.1 is aiming for. (Anthropic

In short, Fable 5.1 is less of an "AI that writes a lot of code" and more of a:

Responsible lead who isolates difficult problems, gathers necessary information, tries multiple methods, verifies evidence, and finally compiles the results.

3. What Improved in Benchmarks?

According to major scores released by Anthropic, Fable 5.1 has seen significant growth in long-term agents, scientific research, and business automation.

In Terminal-Bench-Science 0.1, which measures scientific terminal tasks, it rose from 24.7% in Fable 5 to 52.6%. In Terminal-Bench 4.0, which measures general agent coding, it scored 55.8% compared to Fable 5's 42.0%. Mythos 5.1, with different safety limits, scored 60.9%.

In AutomationBench, which measures business automation, it rose from 17.1% in Fable 5 to 31.4%. In CursorBench 3.2, Fable 5.1 scored 73.4%, compared to 70.5% for Fable 5 and 70.0% for Opus 5.

Additionally, in Humanity’s Last Exam, which measures advanced reasoning across multiple fields, it scored 60.9% without tools and 65.0% with tools. (Anthropic

However, caution is needed when reading these numbers.

These are evaluation results published by Anthropic. Furthermore, Fable has production safety classifiers enabled; in problems where the classifier intervened, it might score zero or the process might shift to another model. Therefore, the difference between Fable and Mythos may include safety setting differences rather than just pure model capability. (Anthropic

Also, at the stage of the day after release, what matters more than being #1 in benchmarks is the "task completion rate" in your own practical work.

For example, in article production, text evaluation alone is insufficient:

• Could it verify facts against primary sources?
• Did it follow the specified character count?
• Did it remove redundancies and contradictions?
• Did it distinguish between citations and summaries?
• Is it consistent from the title to the conclusion?

Unless you prepare such practical evaluations, using the expensive Fable might just result in it thinking for a long time without a better outcome.

4. Adaptive Thinking is Now Always On

In Fable 5.1, Adaptive Thinking is always on.

Unlike previous models, thinking cannot be completely disabled. Specifying thinking: {type: "disabled"} in the API will result in an error. The method where humans specify a fixed number of thinking tokens is also unavailable; the model itself adjusts the amount of thinking based on the problem. (Claude Platform

What users adjust is the "effort."

There are five available levels:

• low
• medium
• high
• xhigh
• max

The default is high.

Official recommendation is to start with high and then lower or raise it based on actual evaluation results. For routine processing, use medium or low; use xhigh or max only for very difficult design, debugging, research, or long-term agent work.

Fable 5.1 is said to produce performance close to the old Fable 5 even at medium, and at low, it may have a higher cost-performance ratio per task than running a smaller model at high effort for certain jobs. (Claude Platform

The important thing here is that internal thinking is also billed as output tokens and consumes max_tokens.

For example, even if the final manuscript displayed on the screen is 10,000 tokens, if it used the equivalent of 10,000 tokens to think beforehand, a total of 20,000 tokens will be subject to output side billing. Since Fable's output unit price is $50 per 1 million tokens, using max unnecessarily will rapidly increase consumption. (Claude Platform

Fable 5.1 is not a model where "higher effort always yields a profit."

Using max for text formatting or summarization may simply increase instances where the model writes a draft internally and then writes it again in the response field. Anthropic also advises using high for long deliverables in principle, and only upgrading to xhigh or above if quality improvement can be measured. (Claude Platform

5. High Prices, but Extremely Cheap Caching

The standard rates for Fable 5.1 are $10 per 1 million input tokens and $50 per 1 million output tokens.

Since Opus 5 is $5/$25 and Sonnet 5 is $2/$10, Fable is twice the price of Opus and five times the price of Sonnet in terms of simple token pricing. (Claude Platform Docs

On the other hand, a major change in Fable 5.1 is the cache read price.

While it was $1 per 1 million tokens in Fable 5, it has become $0.25 in Fable 5.1. This is 2.5% of the normal input price. Anthropic estimates that in typical processing, this will result in a cost reduction of about 25% compared to the old Fable, and up to about 45% for agent processing that repeatedly reads the cache. (Anthropic

For example, if you read a fixed context of 100,000 tokens every time, it would cost $0.10 per time at the normal input rate, but only $0.0025 if it's a cache hit.

In other words, work that repeatedly reads the same project descriptions, tool definitions, codebase premises, and conversation histories in a stable form is more advantageous.

Conversely, usage that rewrites the system prompt every time, reorders tool lists, or deletes and reconstructs old conversations will break the cache.

In Fable 5.1, a non-breaking prompt structure is more directly linked to cost than a clever prompt.

6. Fable 5.1 May Break Existing API Harnesses

When changing only the model name from Fable 5 or Opus, there are three points to be particularly careful about:

Forced tool calling is unavailable

Forcing any or a specific tool name in tool_choice will result in a 400 error.

The reason is that forcing a tool call causes the model to skip normal thinking processes and start thinking inside the tool arguments, which degrades argument quality.

Instead, use tool_choice: auto and explicitly state "Please use the XX tool for this process" within the prompt. If you want to guarantee JSON format, use strict: true or Structured Outputs. (Claude Platform

Conversation history must not be rewritten midway

The thinking block in Fable 5.1 is tied to the system prompt, tools, and past messages at the time that thinking was generated.

If you delete old messages, regenerate the system prompt, or rewrite past tool definitions midway, subsequent thinking blocks will become invalid. For new accounts, a mechanism that makes this condition violation an error is already applied. (Claude Platform

The basic principle is not to edit history, but only to append to the end.

Temporary instructions should be added as turn-scoped system messages, and long contexts should be organized using server-side compaction or context editing.

Internal thinking cannot be carried over when reverting to cheaper models

Fable 5.1 can read thinking blocks created by previous models like Opus 5, Fable 5, or Sonnet.

However, the reverse is not possible. If you pass a thinking block created by Fable 5.1 to Opus or Sonnet, those models cannot read it. (Claude Platform Docs

Therefore, if you switch models within the same conversation, the following order is generally safe:

Explore with cheap models → Promote to Fable

If you return to a cheaper model from Fable, you must leave decisions, unresolved issues, necessary files, and verification results as an explicit handover document without relying on the thinking block.

7. Safety Restrictions and Data Retention

In Fable 5.1, some requests regarding cybersecurity or life sciences are restricted by safety classifiers.

In the standard Claude app, corresponding processes may be automatically routed to Opus 4.8 or Opus 5. In the API, you need to set up fallback settings. You will not be billed Fable rates for processes switched to other models. (Anthropic

Additionally, Fable 5.1 generally requires 30-day data retention. Unless you have received explicit permission from Anthropic, it cannot be used in standard Zero Data Retention environments.

When handling corporate confidential code, customer information, or unpublished research materials, you should introduce it only after confirming the contract and retention conditions, rather than just using it "because the performance is high." (Claude Platform

8. Ultimately, Who Needs Fable 5.1?

Fable 5.1 is for people for whom the completion rate of the entire job, rather than a single model response, is the value.

• Investigation and modification of massive codebases.
• Root cause analysis of hard-to-reproduce bugs.
• Research spanning dozens of documents.
• Tasks that go from research to creating spreadsheets, documents, and slides.
• Long-duration browser operations or backlog processing.
• Research that autonomously plans and executes multiple experiments.

Conversely, there is almost no need to use Fable for email creation, short summaries, simple code generation, routine document organization, or drafting social media posts.

Anthropic itself recommends starting general processing with Opus 5 and only upgrading to Fable if quality is insufficient even when running Opus at high effort. (Claude Platform Docs

Fable 5.1 is not a "standard model for everyone to use from the start," but a high-end model for breaking through difficult points.

Part 2: Token Saving, Prompts, Harnesses, and Skill Construction

1. Token Saving Techniques for Fable 5.1

Saving Tip 1: Don't make Fable do everything from exploration

The most effective saving method is not writing short sentences.

It is reducing the number of times you call Fable itself.

Leave getting file lists, filtering logs, classifying materials, simple summaries, and format conversions to Sonnet, Haiku, or regular scripts.

Use Fable for phases like these:

• Deciding research policy
• Choosing the most promising hypothesis from several
• Integrating contradictory information
• Identifying root causes
• Auditing final deliverables
• Re-examining problems where other models failed

Official documentation also guides configurations using multiple models, with inexpensive models as executors and high-end models as advisors or supervisors. (Claude Platform Docs

Saving Tip 2: Change effort for each step

You don't need to set the entire session to max.

I recommend the following allocation:

Fable 5.1 also provides a mechanism to change effort during a conversation. Rather than rewriting top-level settings, adding effort changes as system messages midway allows you to maintain the prompt cache. (Claude Platform

The correct approach is not "always maximum capability," but "maximum capability only for the difficult moves."

Saving Tip 3: Keep history append-only to protect the cache

In Fable 5.1, keep the following content fixed:

• System prompt
• Tool definitions and order
• Project common rules
• Past messages
• Thinking blocks

Add all changes to the end.

If you are building your own API, it is safer to maintain the same byte-for-byte prefix rather than reassembling the system prompt every time.

In Claude Code, cache processing is basically automated, but you can use cache_control in the API. For multi-turn conversations, use automatic caching; for separating long fixed materials, use explicit cache boundaries. (Claude

Saving Tip 4: Don't put tool output in as-is

Handing 10,000 lines of logs to Claude and asking it to "find the error" is wasteful.

Filter them first with scripts or hooks.

Claude Code's official cost guide also recommends pre-processing long logs with hooks and passing only the necessary few hundred lines to the model. It also explains that using CLIs like gh, aws, or gcloud when available is easier for suppressing context consumption from tool definitions than connecting a large number of MCP servers. (Claude

Before letting the AI read it, cut what can be cut by machine.

Saving Tip 5: Group independent tool calls

When reading five files, if you split it into five turns with one file each, the conversation history is sent every time.

Including the following instruction in Fable 5.1 is effective:

"Organize necessary information internally, and execute reads, searches, and verifications that do not depend on each other's results in parallel within the same turn."

Anthropic also explains that by encouraging the grouping of independent tool calls in a single response, you can reduce round trips, tokens, and wait times. (Claude Platform

Saving Tip 6: Don't let it rewrite the whole file for small fixes

Fable 5.1 may rewrite an entire file even for small changes.

Include this sentence in your common rules:

"If the final result does not change, do not rewrite the entire file; edit only the necessary parts with minimal diffs."

This is particularly effective for long Markdown, JSON, config files, LPs, and massive source code. By preventing full regeneration, you can suppress output tokens and the burden of diff verification. (Claude Platform

Saving Tip 7: Don't continue unrelated work in the same session

In Claude Code, use /clear when moving to unrelated work.

In long conversations, even adding one short question means handling past conversations, read files, and tool results again. Even if the cache works, it's not free.

If you don't want to pollute history with temporary questions, use /btw; if you want to keep only necessary content, use /compact. Offload codebase exploration to subagents and return only summaries to the main conversation. (Claude

2. Practical Prompts for Fable 5.1

For Fable 5.1, it is more effective to clearly pass the objective, scope, completion conditions, and verification methods rather than specifying dozens of detailed thinking steps.

Below is a basic template that can be adapted for coding, research, article production, and document creation.

Role

You are the person responsible for executing this request to completion.

You are in charge of not just answering, but also necessary research, work, verification, and correction.

Objective

[Write the final product to be created or the problem to be solved]

Input

[Write files, URLs, materials, and prerequisites]

Scope

To be implemented:

• [Mandatory task]
• [Mandatory task]

Not to be implemented:

• [Out of scope]
• [Content you don't want changed arbitrarily]

Completion Conditions

The task is complete when all the following conditions are met:

1. [Conditions for function/content]
2. [Conditions for format/character count/quality]
3. [Verification method]
4. [Evidence showing there are no errors]

Execution Rules

• First, organize necessary information and dependencies.
• Execute searches, reads, and verifications that do not depend on each other's results in parallel.
• Proceed with reversible work within the scope of the request without asking for permission midway.
• Confirm the cause before fixing, not just the symptoms of the problem.
• Do not perform unrequested feature additions, optimizations, or peripheral fixes; separate them as suggestions at the end.
• Edit files with minimal diffs whenever possible.
• After work, verify according to the initial completion conditions.
• If verification fails, investigate the cause, fix it, and verify again.
• Do not end by writing "what to do next"; execute that work.
• Confirm before execution only for destructive operations or major specification changes.

Final Report

Finally, report briefly in the following order:

1. What was completed
2. Changes made
3. Verification results and evidence
4. Remaining issues
5. Improvement candidates noticed but out of scope

Fable 5.1 can continue working for a long time, but if it's ambiguous what constitutes completion, it will continue exploring more than necessary.

Therefore, writing completion and stop conditions is more important than saying "think deeply."

3. Harness Design to Leverage Fable 5.1

A harness is the mechanism of work surrounding the model.

Rather than relying solely on the model's capability, you decide from the outside what information to pass, what tools to use, in what order to proceed, where to verify, and how many times to retry on failure.

I recommend the following 6-layer structure:

Layer 1: Common Rules

In CLAUDE.md, place only the project facts needed every time.

Project

• This repository is for the XX service
• The production environment is XX
• Use pnpm for package management

Required checks

• pnpm lint after changes
• pnpm test after changes
• Type check on API changes

Constraints

• Do not break compatibility with existing APIs
• Do not output secret information to logs
• Do not refactor outside the request

Since CLAUDE.md is read in every session, making it too long will consume context every time. Official documentation recommends keeping one file under 200 lines and moving long procedures to Skills. (Claude

Layer 2: Router

When a request is received, classify the work instead of starting Fable immediately.

• Simple extraction/formatting -> Haiku or script
• Normal implementation/research -> Sonnet
• Complex design/analysis -> Opus
• Long-term work/difficult problems -> Fable
• Only failed difficult points -> Fable xhigh

When creating an automatic router, judge based on "loss if incorrect," "required autonomous time," and "difficulty of verification" rather than price.

Layer 3: Exploration Lead

Separate code exploration, material collection, and competitor research into subagents.

Each subagent works in an independent context and returns only conclusions and evidence to the main agent. This prevents the reading results of dozens of files from bloating the main history. (Claude

Layer 4: Fable Supervisor

Fable makes judgments using the results returned from the exploration leads.

• Which hypothesis to adopt
• Whether additional research is needed
• Which changes to make
• Whether there are contradictions in the results
• Whether completion conditions were met

Rather than making Fable responsible for everything down to raw data collection, pass it organized evidence and let it focus on judgment.

Layer 5: Deterministic Verification

Don't leave verification solely to prompts.

• For code: Tests, Lint, type checks.
• For articles: Character count, duplicate expressions, URLs, citations.
• For spreadsheets: Formula errors, missing values, totals.
• For LPs: Links, layout breaks, screenshot comparisons.

Using hooks, you can run inspections before and after tool execution. Instead of betting on the LLM remembering to verify, execute it automatically under fixed conditions. (Claude Platform Docs

Layer 6: Repair Loop

Return to Fable only if verification fails.

Creation -> Mechanical Verification -> Success (Complete) / Failure -> Cause Analysis -> Minimal Fix -> Re-verification

The important thing is not to loop indefinitely.

For example, decide "up to 2 times for the same failure" or "stop with evidence after 3 total failures." For models that can work for a long time, costs and work scope will balloon without stop conditions.

For processes using dozens to hundreds of subagents, move to a Dynamic Workflow rather than letting Claude manage them sequentially. In a Workflow, you can hold intermediate results in script variables and return only the final result to the main context, making it suitable for large-scale research or processing massive files. (Claude

4. Skills are Not "Long Prompt Storage"

Skills are a mechanism to save work procedures used repeatedly as SKILL.md.

The difference from CLAUDE.md is that the body is read only when needed.

• Project info and short rules to always follow: CLAUDE.md.
• Procedures for article production, deployment, research, review, etc.: Skills.
• Large amounts of examples or specifications: Reference files for Skills.

This separation directly links to token savings. (Claude Platform Docs

I recommend the following structure:

1.claude/
2├── CLAUDE.md
3├── skills/
4│   └── deep-article/
5│       ├── SKILL.md
6│       ├── research-rules.md
7│       ├── writing-rules.md
8│       ├── examples.md
9│       └── scripts/
10│           ├── count_chars.py
11│           └── check_repetition.py
12├── agents/
13│   ├── researcher.md
14│   └── critic.md
15└── settings.json

In SKILL.md, place only the overview, execution conditions, procedures, and completion conditions.

Separate massive explanations, API specs, and success stories into different files and let Claude read them only when necessary. Official documentation recommends keeping SKILL.md under 500 lines and separating detailed materials into supporting files. (Claude Platform Docs

5. Practical SKILL.md Template

Below is an example of a Skill for creating research articles.

name: deep-article

description: Researches primary information and creates long-form articles with evidence. Use when requested for thorough explanations of the latest AI, companies, systems, or products.

argument-hint: "[Theme] [Target character count]"

effort: high

Objective

Create a fact-checked long-form article about $ARGUMENTS.

Basic Rules

• Always search if latest information is relevant
• Prioritize primary information
• Distinguish between facts, corporate announcements, third-party evaluations, and speculation
• Attach target periods and definitions to numbers
• Do not repeat the same conclusions or examples
• Explain technical terms upon first mention
• Do not end with less than 90% of the specified character count
• Finally, report character count and unverified items

Workflow

1. Divide the theme into 3-7 research points
2. Research independent points in parallel
3. Gather primary information
4. Investigate counter-evidence or unfavorable information
5. Create a fact list
6. Decide the structure
7. Create the first draft
8. Audit for duplicates, leaps, citations, dates, and numbers
9. Correct
10. Inspect character count

Completion Conditions

• Conclusion is clear at the beginning
• Reader can decide what to do
• Important facts have sources
• Facts and speculation are not mixed
• Meets specified character count
• No duplicate paragraphs

Materials to read only when necessary

• Research standards: research-rules.md
• Style standards: writing-rules.md
• Good completion examples: examples.md

Final Inspection

Execute the following:

• python ${CLAUDE_SKILL_DIR}/scripts/count_chars.py <output-file>
• python ${CLAUDE_SKILL_DIR}/scripts/check_repetition.py <output-file>

The description of a Skill functions as a router, not just an explanation.

Rather than an ambiguous sentence like "Write high-quality articles," writing "Use for long-form requests investigating primary information about latest AI, companies, and systems" makes it easier to be called in necessary situations.

Since Claude Code puts the list of Skill descriptions into the context, writing massive descriptions increases constant costs. Put important uses at the beginning and keep them short. (Claude Platform Docs

6. Advanced Usage of Skills

Skills that must not be auto-executed

Deployment, sending, deleting, publishing, and payments must not be started by Claude arbitrarily.

Set disable-model-invocation: true and only run them when the user explicitly enters /deploy, etc.

Skills that shouldn't pollute the conversation

For Skills that perform massive research or code exploration, set context: fork.

This causes them to execute in a separate subagent context. Massive file contents and search histories won't enter the main conversation; only the final result returns. (Claude Platform Docs

Skills that auto-inject current state

Within a Skill, you can pre-insert command results.

Current state

!git status --short

!git diff --stat

Claude receives the execution result, not the command string.

However, injecting full git diffs or massive logs every time is counterproductive. Put in only --stat or error lines first, and let it read details only when they become necessary. (Claude Platform Docs

Setting effort for Skills

Set simple Skills to medium, design reviews and deep research to high, and extremely difficult audits to xhigh.

If you give each Skill its own effort, the user doesn't need to switch every time.

7. Always Comparatively Evaluate Skills

Just creating a Skill doesn't tell you if quality improved.

Official documentation guides evaluating two things separately:

1. Does the Skill start correctly for necessary requests?
2. Does the deliverable actually get better as a result of starting?

Execute the same request in new sessions both "with Skill" and "without Skill."

For an article Skill, compare character count, missing sources, duplicates, factual errors, and number of corrections. For a code Skill, compare test success rate, number of changed files, unnecessary changes, and number of re-works.

Testing in the continuation of the conversation where you created the Skill will hide defects with supplementary information from the conversation. Always evaluate in a new session. Claude Code also provides an official skill-creator plugin to support this comparison. (Claude Platform Docs

Final Conclusion

Claude Fable 5.1 is not a model that simply speeds up the Claude series.

Its greatest value is its ability to continue difficult work for a long time, recover from midway failures, search for root causes, and carry work to completion while verifying its own results.

On the other hand, input and output unit prices are twice those of Opus 5. Internal thinking cannot be turned off, it is incompatible with harnesses that rewrite old conversations, and forced tool calling is unavailable.

Therefore, the strongest way to use it is as follows:

**Narrow down information with Sonnet or scripts.

Separate exploration with subagents.

Assign Fable to difficult judgments and integration.

Verify mechanically with hooks and tests.

Raise effort only for failed difficult points.

Save repeating procedures in Skills.

Keep conversation history append-only to protect the cache.**

If you use Fable 5.1 as a "high-end chat that answers anything," only the price will be high.

The true difference from previous generations emerges only when you position Fable 5.1 as the supervisor bundling cheap models, Skills, subagents, hooks, and verification loops.