Claude Fable 5: When to Use the Powerful Model and Which Effort Level to Choose

Claude Fable 5 is Anthropic's flagship model belonging to the novel Mythos architectural class, engineered specifically for rigorous multi-step reasoning and autonomous agentic workflows. Alongside this model, developers gained a fundamental behavioral control lever: the effort parameter.

This guide explores Fable 5's capabilities, how the effort parameter operates under the hood, how hidden thinking tokens are billed, and how to select optimal configurations to balance latency, accuracy, and operational cost in production.

1. Fable 5 in a Nutshell: What This Model Is and Why It’s Needed

Claude Fable 5 stands as the most capable widely available model from Anthropic, positioned above the Opus tier. It is designed for challenging scenarios where traditional frontier models hit cognitive walls or lose thread continuity across long execution loops.

1.1. Model Positioning and the Mythos Class

Fable 5 is the first commercially accessible model derived from the Mythos architecture. A specialized research sibling, Mythos 5, operates without standard output safeguards and is restricted exclusively to vetted research teams via Project Glasswing.

The model is natively supported within Claude Code and the Managed Agents platform, offering a 1,000,000 token context window and up to 128,000 output tokens per single generation turn.

1.2. Benchmarks, Multimodality, and No-Slop Code

In rigorous empirical evaluations, Fable 5 establishes State-of-the-Art (SOTA) benchmarks across demanding disciplines:

• Agentic Coding: Autonomous workspace setup, bug localization, test generation, and full-stack refactoring.
• No-Slop Code Output: Generates clean, idiomatic code free of boilerplate wrappers, synthetic placeholders, or unnecessary abstractions.
• Pure Visual Interaction: Successfully navigated and completed gameplay tasks in Pokemon FireRed guided purely by video screenshots without text prompts.
• Scientific Modeling: Complex CAD geometry generation in VibeCAD and biomedical sequence reasoning.

The defining characteristic of Fable 5: its competitive advantage over Sonnet and Opus expands exponentially on prolonged multi-turn tasks.

2. When It Makes Sense to Use Fable 5, and When It Doesn’t

Because Fable 5 commands a premium cost and higher latency, deployment must be grounded in sound engineering rationale.

2.1. Optimal and Inefficient Use Cases

Fable 5 proves its value where the cost of human remediation or logic failure is high:

2.2. Four Rules for Production Deployment and Access Tiers

Before rolling out Fable 5 into production pipelines, incorporate four essential design principles:

1. Streamline System Prompts: Fable 5 thrives on conceptual objectives. Rigid, micro-managed procedural scripts inherited from older models constrain its reasoning—specify clear success conditions and guardrails instead.
2. Treat Effort as a Cost Lever: Calibrating effort is your primary mechanism for controlling latency and API token spend.
3. Budget for Prolonged Turns: Complex frontier reasoning cycles can take several minutes; enforce explicit iteration caps on agentic loops.
4. Build Resilient Refusal Handlers: Given strict safety thresholds, certain boundary queries trigger refusals, necessitating graceful fallback logic in client code.

3. What Effort Actually Does and How It Works

With the introduction of Fable 5, Anthropic retired conventional sampling knobs (temperature, top-p) and manual budget_tokens controls.

3.1. Behavioral Signal vs. Hard Token Budget

The primary tuning mechanism is the effort parameter, passed inside output configuration: output_config={"effort": "..."}.

3.2. Impact on Tool Calls, Explanations, and Generation

Unlike the legacy budget_tokens setting, which governed only the internal chain-of-thought phase, effort influences every component of the response:

• At low effort: The model issues fewer tool calls, bundles operations into consolidated queries, omits conversational preamble, and delivers concise answers.
• At high / xhigh effort: The model drafts extensive working plans, performs self-verification via auxiliary tool invocations, and produces detailed documentation and code comments.

4. Five Effort Levels and Where Each Is Available

The Messages API accepts an explicit set of five documented effort string values.

4.1. The Official Scale from Low to XHigh

4.2. Model Support Matrix and Per-Model Calibration

The xhigh tier is selective: models such as Opus 4.6 and Sonnet 4.6 do not support it. Furthermore, the effort scale is calibrated independently for each model family—high on Fable 5 engages far deeper reasoning than high on Opus 4.6.

5. Defaults Across Models and Environments: API and Claude Code

Execution environments establish different default effort values when parameters are left unspecified.

5.1. Comparing Defaults in the API and Claude Code

5.2. Fallback Behaviors and Session Persistence

• Automatic Fallback: If you configure xhigh and subsequent execution switches to Opus 4.6, Claude Code smoothly falls back to high without interrupting the session.
• Persistence Rules: Levels between low and xhigh persist across recurring Claude Code sessions. The max level is intentionally session-scoped and resets upon restart to prevent accidental budget depletion.

6. How Effort Relates to Model Thinking

Internal reasoning mechanics differ significantly across Claude generations.

6.1. Fable 5 Constraints vs. Adaptive Thinking in Opus

• Fable 5: Thinking is architecturally integrated and permanently active. Attempting to disable it via thinking: {"type": "disabled"} triggers an HTTP 400 Bad Request error.
• Opus 4.7 / 4.8: Adaptive thinking is disabled by default and must be explicitly enabled via thinking: {"type": "adaptive"}.

6.2. Migrating from the Deprecated budget_tokens Parameter

7. Cost Breakdown: What Each Effort Level Really Costs

The effort parameter does not modify the per-token base price. It drives financial spend indirectly by varying the volume of generated thinking tokens.

7.1. Pricing of Hidden Thinking Tokens

On Fable 5, thinking tokens are omitted from user-facing text by default, yet each generated thinking token is billed as a full output token at standard rates: $10 per 1M input tokens and $50 per 1M output tokens.

7.2. Per-Turn Cost Calculations and Tokenizer Effects

Estimated turn cost for an agentic workload with 20,000 input tokens (modeled on Opus 4.8 rates of $5/$25):

8. Choosing the Right Effort Level for Your Task

Adopt a deliberate tiering strategy to balance model power against resource consumption.

8.1. Selection Strategies for Fable 5 and Opus

8.2. Multi-Tier Architecture: Orchestrator and Subagents

The most cost-effective production pattern utilizes a hierarchical architecture:

• Lead Orchestrator: Fable 5 operating on high or xhigh (constructing task trees, directing agents, reviewing pull requests).
• Worker Subagents: Sonnet 4.6 or Fable 5 configured on low (executing isolated edits, running test commands, querying documentation).

9. Configuring Effort in Practice: Claude Code and the API

Effort levels can be configured both via interactive CLI environments and programmatically within the Messages API.

9.1. Settings in Claude Code CLI and Ultracode Mode

Claude Code provides several configuration entry points:

• Use /effort to launch an interactive slider.
• Launch with a direct flag: claude --effort xhigh.
• Set an environment variable: export CLAUDE_CODE_EFFORT_LEVEL=xhigh.

9.2. Messages API Integration and Fast Mode

python
Copy
import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=64000,
    output_config={"effort": "xhigh"},
    messages=[
        {"role": "user", "content": "Perform a zero-dependency microservices audit"}
    ]
)
print(response.content[0].text)

10. Frequently Asked Questions (FAQ)

10.1. Availability of XHigh and Model Fallbacks

Question: Is the xhigh effort level available on every Claude model?
Answer: No. xhigh is supported exclusively on Fable 5, Mythos 5, Opus 4.8, and Opus 4.7. Attempting to select xhigh on Opus 4.6 or Sonnet 4.6 within Claude Code automatically defaults to high.

10.2. Per-Token Pricing vs. Total Execution Cost

Question: Does selecting a higher effort level increase the price per individual token?
Answer: No. The unit cost per 1M tokens remains constant ($10 input / $50 output for Fable 5). Higher effort costs more because the model generates substantially more thinking tokens and issues more comprehensive tool calls.

10.3. Ultracode vs. The Ultrathink Prompt Directive

Question: What distinguishes ultracode from the ultrathink prompt keyword?
Answer: ultracode is an execution mode in Claude Code pairing xhigh with autonomous agent permissions. In contrast, ultrathink is a user prompt directive requesting deeper reasoning on a specific conversational turn.

10.4. Best Practices for Running Maximum Effort in Production

Question: Should production systems run Fable 5 on xhigh by default?
Answer: No. Anthropic guidance advises starting at high. Running Fable 5 on xhigh indiscriminately introduces unnecessary latency and cost without meaningful quality gains for routine workflows.