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

> A comprehensive breakdown of Claude Fable 5 and the effort parameter: behavioral reasoning signals, level availability matrix (low to xhigh), per-turn cost calculations, and practical API/Claude Code setups.

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.

> [!NOTE]
> In web environments, Fable 5 is included within Pro and Max subscriptions. In the Messages API, it is accessed via the model identifier `claude-fable-5`.

### 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:

| Recommended Applications | Unjustified Premium |
| --- | --- |
| Deep architectural refactoring and monolithic codebase migrations | Routine CRUD controllers and boilerplate script writing |
| Autonomous agent runs spanning 20 to 100+ sequential tool turns | Single-shot text classification or entity extraction |
| Tracking down subtle race conditions and security vulnerabilities | Standard unit test scaffolding for trivial functions |
| System architecture design from high-level specifications | Summarizing short meeting transcripts or email threads |

### 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": "..."}`.

> [!IMPORTANT]
> The `effort` parameter acts as a qualitative behavioral signal rather than a rigid token limit. It guides the model on how extensively to explore hypothesis trees and verify solutions. The only hard generation ceiling remains `max_tokens`.

### 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

| Level | Anthropic Documentation Definition | Model Availability |
| :--- | :--- | :--- |
| **xhigh** | Maximum reasoning depth for extended agentic sessions (>30 min) with multi-million token budgets | Exclusively Fable 5, Mythos 5, Opus 4.8, Opus 4.7 |
| **high** | Default setting: comprehensive reasoning, systematic planning, and step verification | All models supporting the effort parameter |
| **medium** | Balanced performance offering moderate token savings with sound reasoning | All models supporting the effort parameter |
| **low** | Maximum execution speed and minimal token overhead for latency-sensitive tasks | All models supporting the effort parameter |
| **max** | Extreme, unbounded reasoning reserved for frontier scientific discovery | Specialized Claude Code environments |

### 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

| Model Family | Messages API Default | Claude Code CLI Default |
| :--- | :--- | :--- |
| **Claude Fable 5** | `high` | `high` |
| **Claude Opus 4.8** | `high` | `high` |
| **Claude Opus 4.7** | `high` | `xhigh` |
| **Claude Opus 4.6 / Sonnet 4.6** | `high` | `high` |

### 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

> [!WARNING]
> In current API versions, providing the legacy `budget_tokens` parameter throws an API error. Migrate all integration code to pass `output_config={"effort": "..."}`.

---

## 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):

| Scenario & Effort Level | Output Tokens | Input Cost ($5/M) | Output Cost ($25/M) | Total Cost Per Turn |
| :--- | :--- | :--- | :--- | :--- |
| **low** (concise, streamlined tools) | 5,000 | $0.10 | $0.125 | **~$0.23** |
| **high** (planning, code validation) | 20,000 | $0.10 | $0.50 | **~$0.60** |
| **xhigh** (deep architectural exploration) | 60,000 | $0.10 | $1.50 | **~$1.60** |

> [!TIP]
> For Fable 5, double these output figures ($50/M output rate). Across a 50-turn agent run, tuning from `xhigh` to `high` or `low` can represent the difference between $30 and $160+ for identical high-level outcomes.

---

## 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

:::tabs
=== Fable 5 (Flagship Reasoning)
Begin with the default **high** level. On Fable 5, `high` routinely exceeds the reasoning depth of `xhigh` on older models. Escalate to `xhigh` strictly for mission-critical tasks lasting over 30 minutes or clean-slate architectural designs.
=== Opus 4.8 / 4.7 (Coding)
The recommended starting configuration for complex development is **xhigh**. This fully unlocks Opus's analytical code evaluation. Step down to `medium` once core test suites pass.
=== Background Automation (low)
Deploy **low** for routine subagent runs, documentation generation, schema parsing, and high-throughput tasks where minimal latency is paramount.
:::

### 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`.

> [!NOTE]
> The **ultracode** option in Claude Code's `/effort` menu is a client-level preset combining the `xhigh` API setting with automated multi-turn permission grants for long autonomous execution loops.

### 9.2. Messages API Integration and Fast Mode

:::tabs
=== Python SDK
```python
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)
```
=== TypeScript SDK
```typescript
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

const response = await anthropic.messages.create({
  model: "claude-fable-5",
  max_tokens: 64000,
  output_config: { effort: "xhigh" },
  messages: [
    { role: "user", content: "Perform a zero-dependency microservices audit" }
  ],
});
console.log(response.content[0]);
```
=== cURL (Messages API)
```bash
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 64000,
    "output_config": {"effort": "high"},
    "messages": [{"role": "user", "content": "Hello Fable!"}]
  }'
```
:::

---

## 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.