HOW-TO: Set Up Claude Fable 5 for Agentic Coding Workflows

Overview

Claude Fable 5 (model ID: claude-fable-5) is Anthropic's purpose-built model for long-horizon agentic coding tasks — multi-file refactors, framework migrations, and complex feature implementations that span dozens of files and hundreds of steps.

What makes Fable 5 different:

• Trained specifically for extended autonomous coding sessions (100+ tool calls, 30+ minute tasks)
• Optimized for planning, self-correction, and maintaining context across long workflows
• ~1M token context window with 128K max output
• Built-in safeguards that automatically reroute high-risk sessions to Opus 4.8

Why use Fable 5 for agentic coding:

• Multi-step tasks: Handles refactors that touch 20+ files without losing track
• Self-correction: Catches its own errors mid-flow and fixes them before moving on
• Context retention: Remembers architectural decisions made 50 steps ago
• Reduced handholding: Requires less explicit instruction than Opus for coding-specific tasks

When to choose Fable 5 vs Opus 4.8:

Use Case	Recommended Model
Multi-file refactors, migrations	Fable 5
Complex feature implementation	Fable 5
Code review, architecture design	Opus 4.8
General-purpose reasoning, non-coding	Opus 4.8
Quick one-off script generation	Sonnet 4.5 (cheaper)
Tasks requiring creative writing	Opus 4.8

Rule of thumb: If the task involves editing more than 5 files or running more than 20 tool calls, use Fable 5. For everything else, Opus or Sonnet will serve you better and cheaper.

See also: Claude Fable 5 Mythos 5 Analysis 2026 06 10 for a deep technical analysis of Fable 5's architecture and benchmarking.

---

Prerequisites

Before getting started, ensure you have the following:

1. Anthropic API Key

You need an active Anthropic API account with access to the Fable 5 model.

• Sign up at console.anthropic.com
• Generate an API key under API Keys → Create Key
• Store it securely: export ANTHROPIC_API_KEY="sk-ant-..."

Free access period: Fable 5 is free for Pro, Max, Team, and Enterprise subscribers from June 9–22, 2026. After this window, standard pricing applies ($10/M input, $50/M output).

2. Anthropic SDK (Python)

pip install anthropic

Verify installation:

python -c "import anthropic; print(anthropic.__version__)"

3. Claude Code CLI

Claude Code is Anthropic's agentic coding tool that runs in your terminal:

# Install via npm (requires Node.js 18+)
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version

4. Git Repository

Fable 5 works best with version-controlled codebases. Ensure your project has:

• A working Git repository
• Clean working tree (commit or stash changes before starting)
• Adequate disk space for potential file modifications

---

Quick Start: One-Line API Switch

Switching from Opus 4.8 to Fable 5 requires changing a single parameter. Here's the minimal Python example:

from anthropic import Anthropic

client = Anthropic()

# Switch from "claude-opus-4-8-20260301" to "claude-fable-5"
msg = client.messages.create(
    model="claude-fable-5",
    max_tokens=8192,
    messages=[
        {"role": "user", "content": "Plan and implement the refactor in this repo."}
    ],
)

print(msg.content[0].text)

That's it. The model ID claude-fable-5 is all you need.

Environment Variable Override

For quick testing without code changes:

# Override model via environment variable (if your tooling supports it)
export ANTHROPIC_MODEL="claude-fable-5"

---

Claude Code Setup

Claude Code is the primary interface for using Fable 5 in agentic coding workflows. Here's how to configure it.

Step 1: Initialize Claude Code in Your Project

cd /path/to/your/project
claude init

This creates a .claude/ directory with configuration files.

Step 2: Configure Fable 5 as Default Model

Edit .claude/settings.json:

{
  "model": "claude-fable-5",
  "effort": "high"
}

Configuration options:

Setting	Values	Description
model	claude-fable-5, claude-opus-4-8-20260301, claude-sonnet-4-5-20250514	Model to use for coding tasks
effort	high, medium, low	Reasoning depth — high for complex refactors, medium for routine tasks
maxTurns	Integer (default: 100)	Maximum tool-call turns before stopping
allowTools	Array of tool names	Restrict which tools the agent can use

Step 3: Run Your First Agentic Task

# Basic usage
claude --model claude-fable-5 "Migrate this codebase from Ruby 2.7 to 3.3"

# With explicit effort level
claude --model claude-fable-5 --effort high "Refactor the authentication module to use OAuth2"

# With a specific file scope
claude --model claude-fable-5 "Fix the memory leak in src/workers/processor.py"

Step 4: Verify the Session

During execution, Claude Code displays:

• Current step in the plan
• Files being modified
• Tool calls being made
• Cost estimates in real-time

🦞 Claude Code (claude-fable-5) — High Effort
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 3/47: Refactoring user authentication logic
  → Modified: src/auth/login.py (12 changes)
  → Modified: src/auth/middleware.py (5 changes)
  → Running: pytest tests/auth/
  ✓ 42/42 tests passing

Estimated cost so far: $2.34

Advanced: Per-Project Configuration

For teams, create a .claude/claude-code-config.json at the repository root:

{
  "model": "claude-fable-5",
  "effort": "high",
  "maxTurns": 200,
  "allowTools": ["read", "write", "edit", "exec", "bash", "git"],
  "permissions": {
    "allowFileWrite": true,
    "allowExec": true,
    "allowGit": true,
    "allowNetwork": false
  },
  "customInstructions": "Always run the test suite after making changes. Prefer incremental commits over single large commits."
}

---

Cost Management

Fable 5 is Anthropic's most expensive model. Understanding the cost structure is critical for production use.

Pricing Structure

Component	Price
Input tokens	$10 per 1M tokens
Output tokens	$50 per 1M tokens
Cache read	$2.50 per 1M tokens
Cache write	$1.25 per 1M tokens

Cost Estimates by Task Size

Task Type	Est. Input	Est. Output	Est. Cost
Single file fix	10K tokens	5K tokens	~$0.35
Small refactor (3-5 files)	50K tokens	20K tokens	~$1.50
Medium refactor (10-20 files)	200K tokens	80K tokens	~$6.00
Large migration (50+ files)	500K tokens	200K tokens	~$15.00
Full codebase overhaul	1M tokens	400K tokens	~$30.00

Note: These are rough estimates. Actual costs depend on codebase size, number of iterations, and how much the model needs to "think" (tool calls, test runs, error recovery).

Cost Optimization Strategies

1. Use caching for repeated context:

from anthropic import Anthropic

client = Anthropic()

msg = client.messages.create(
    model="claude-fable-5",
    max_tokens=8192,
    messages=[
        # Cache the system prompt and repo context (read-only, reused across calls)
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Here is the full repository context...\n" + repo_contents,
                    "cache_control": {"type": "ephemeral"}
                }
            ]
        },
        {"role": "user", "content": "Now refactor the payment module."}
    ],
)

Caching reduces input costs by 75% on subsequent calls that reuse the same context.

2. Scope your tasks narrowly:

# ❌ Too broad — will burn through tokens
claude --model claude-fable-5 "Refactor this entire codebase"

# ✅ Scoped — focused, cheaper, more effective
claude --model claude-fable-5 "Refactor the payment processing module: src/payments/, tests/payments/"

3. Use Sonnet 4.5 for simple tasks:

# Quick one-off: use Sonnet ($3/M in, $15/M out)
claude --model claude-sonnet-4-5-20250514 "Add input validation to the signup form"

# Complex multi-file work: use Fable 5
claude --model claude-fable-5 "Migrate the entire authentication system to JWT"

4. Set budget limits in Claude Code:

{
  "model": "claude-fable-5",
  "maxCost": 20.00,
  "costAlertThreshold": 15.00
}

5. Monitor costs in real-time:

# Check current session cost
claude cost

# Check monthly usage
claude cost --monthly

---

Understanding Safeguards

Fable 5 includes automatic safety safeguards that can reroute your session to Opus 4.8 if risky behavior is detected.

What Triggers the Fallback

The safeguards monitor for:

• Destructive operations: rm -rf, database drops, production deployments without confirmation
• Credential exposure: Attempting to write API keys to files, exfiltrating secrets
• System modifications: Changing system configurations, installing packages globally
• Network actions: Making unauthorized external API calls, sending data to unknown endpoints
• Social engineering: Attempts to bypass safety guidelines or manipulate the model

Fallback Behavior

When triggered:

1. The current session is paused
2. The request is rerouted to Opus 4.8 for evaluation
3. Opus 4.8 decides whether to allow, modify, or block the action
4. You receive a notification explaining the trigger

Statistics: Less than 5% of sessions trigger a fallback. Most coding workflows proceed without interruption.

Working Around False Positives

Scenario 1: Legitimate rm commands in build scripts

# ❌ May trigger safeguard
claude --model claude-fable-5 "Clean up the build directory and restart"

# ✅ Be explicit about what's safe
claude --model claude-fable-5 "Remove the contents of the ./dist/ directory only, then run npm run build"

Scenario 2: Database migrations

# ❌ Vague — could be interpreted as destructive
claude --model claude-fable-5 "Reset the database"

# ✅ Specific and safe
claude --model claude-fable-5 "Run the migration script at db/migrate/001_add_users_table.sql against the staging database only"

Scenario 3: Installing packages

# ❌ Global install may trigger
claude --model claude-fable-5 "Install the latest version of everything"

# ✅ Scoped to project
claude --model claude-fable-5 "Add 'pytest' and 'black' to requirements-dev.txt and install them in the virtual environment"

General guidelines to avoid false positives:

• Be specific about file paths and scopes
• Explicitly mention environments (staging, dev, not production)
• Use --dry-run flags where available
• Confirm destructive actions in your prompts
• Keep credentials in environment variables, never in prompts

---

Best Practices

Prompt Patterns for Long-Horizon Tasks

Pattern 1: Phased approach with checkpoints

You are refactoring the authentication system. Follow these phases:

Phase 1: Analysis
- Read all auth-related files
- Document the current architecture
- Identify dependencies and potential breaking changes

Phase 2: Implementation
- Migrate to JWT-based auth
- Update all affected endpoints
- Maintain backward compatibility for 30 days

Phase 3: Testing
- Run existing test suite
- Add new tests for JWT flows
- Verify no regression in user login

Phase 4: Documentation
- Update API docs
- Write migration guide for consumers

Stop after each phase and wait for confirmation before proceeding.

Pattern 2: Explicit constraints

Refactor the payment module with these constraints:
- Do NOT modify the database schema
- Do NOT change the public API endpoints
- Do NOT touch the logging infrastructure
- You MAY modify: src/payments/, tests/payments/, src/models/payment.py
- Run `pytest tests/payments/` after every change
- Commit after each logical unit with descriptive messages

Pattern 3: Self-review loop

Implement the feature, then:
1. Run the full test suite
2. Review your changes with `git diff`
3. Identify any potential edge cases you missed
4. Fix any issues found
5. Write a summary of changes for the PR description

When to Use High Effort vs Medium Effort

Scenario	Effort Level	Reasoning
Framework migration (Rails 6 → 7)	High	Complex, many interdependencies
Adding a new feature to existing codebase	High	Needs deep understanding of architecture
Bug fix in isolated module	Medium	Focused scope, less context needed
Code style updates / linting fixes	Low	Mechanical, low reasoning required
Writing tests for existing code	Medium	Needs understanding but not deep refactoring
Database schema migration	High	High risk, needs careful planning

Cost impact: High effort uses ~2-3x more tokens than medium effort. Reserve it for tasks where the additional reasoning actually improves outcomes.

Workflow Integration

Git workflow with Claude Code:

# Create a feature branch
git checkout -b feat/payment-refactor

# Run Fable 5 on the task
claude --model claude-fable-5 --effort high "Refactor payment processing to use Stripe v3 API"

# Review changes
git diff --stat
git log --oneline -10

# Commit with AI-generated messages (Fable 5 auto-commits during sessions)
git log --oneline -5

CI/CD integration:

# .github/workflows/claude-review.yml
name: Claude Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Claude Code Review
        uses: anthropics/claude-code-action@v1
        with:
          model: claude-fable-5
          effort: medium
          prompt: "Review this PR for bugs, security issues, and performance problems."
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

---

Comparison: Fable 5 vs Open-Source Alternatives

Fable 5 vs Qwen3.6 (Local Deployment)

Feature	Claude Fable 5	Qwen3.6 (Local)
Cost	$10/M in, $50/M out	Free (your hardware costs)
Context	~1M tokens	128K–200K tokens
Max Output	128K tokens	8K–32K tokens
Agentic Capability	Production-ready, 100+ tool calls	Emerging, 20-50 tool calls
Self-Correction	Built-in, robust	Variable, depends on prompting
Setup Complexity	API key + SDK	Hardware, quantization, serving
Privacy	Data sent to Anthropic	Fully local, no data leaves
Latency	~200ms/token (API)	~50-200ms/token (local GPU)
Reliability	High, with safeguards	Depends on your setup

When to Use Fable 5

• Mission-critical refactors where correctness matters more than cost
• Teams without GPU infrastructure — no hardware to manage
• Complex multi-repo tasks requiring 1M+ context
• When you need safeguards for production code
• During the free period (June 9–22, 2026) — test it risk-free

When to Use Qwen3.6 Locally

• Tight budget constraints — recurring API costs are unsustainable
• Privacy-sensitive codebases — IP that cannot leave your network
• Routine tasks — linting, formatting, simple bug fixes
• High-volume workflows — hundreds of small tasks per day
• Experimentation — testing prompts without cost concerns

Hybrid Approach

Many teams use both:

Qwen3.6 (local) → Handle 80% of routine tasks (linting, simple fixes, test writing)
     ↓
Claude Fable 5 → Escalate complex tasks (refactors, migrations, architecture changes)
     ↓
Human review → Final approval on all changes before merge

---

Troubleshooting

Issue: "Model not found" error

anthropic.APIError: No such model: claude-fable-5

Solution: Fable 5 may not be available on your API tier yet. Check:

1. Your account has access (Pro/Max/Team/Enterprise)
2. The model ID is exactly claude-fable-5 (case-sensitive)
3. You're not using a region-restricted endpoint

# List available models
from anthropic import Anthropic
client = Anthropic()
for model in client.models.list():
    print(model.id)

Issue: Session terminated unexpectedly

Session terminated: Maximum turns reached (100)

Solution: Increase maxTurns in your config:

{
  "model": "claude-fable-5",
  "maxTurns": 300
}

Or break the task into smaller phases and run them sequentially.

Issue: Safeguard triggered too often

If you're seeing frequent Opus 4.8 fallbacks:

1. Review your prompts for vague destructive language
2. Add explicit scope constraints to your instructions
3. Use --dry-run for commands that modify system state
4. Consider splitting tasks so each one has a narrower scope

Issue: High costs on simple tasks

Solution: Implement a model routing strategy:

def choose_model(task_complexity: str) -> str:
    if task_complexity == "simple":
        return "claude-sonnet-4-5-20250514"  # $3/M in
    elif task_complexity == "moderate":
        return "claude-opus-4-8-20260301"    # $15/M in
    else:
        return "claude-fable-5"               # $10/M in

Issue: Context window exceeded

anthropic.APIError: Input too large: 1.2M tokens (limit: 1M)

Solution:

1. Scope the task to specific directories/files
2. Use caching for shared context across multiple calls
3. Summarize large files before including them
4. Use .claude/CLAUDE.md to provide project context without dumping entire files

# Scope to specific paths
claude --model claude-fable-5 "Refactor src/payments/ and tests/payments/ only"

Issue: Claude Code not recognizing Fable 5

Unknown model: claude-fable-5

Solution: Update Claude Code to the latest version:

npm update -g @anthropic-ai/claude-code
claude --version

---

Summary

Claude Fable 5 is a powerful tool for agentic coding workflows, particularly excelling at long-horizon tasks that require sustained reasoning across many files and steps. Key takeaways:

• Setup is simple: Change one model ID from claude-opus-4-8-20260301 to claude-fable-5
• Cost matters: At $10/M input and $50/M output, scope tasks carefully and use caching
• Safeguards are helpful: The <5% fallback rate to Opus 4.8 catches real risks without being annoying
• Effort levels matter: Use high for complex refactors, medium for routine work
• Hybrid approaches work best: Combine Fable 5 for complex tasks with cheaper models for routine work

Next steps:

• Try the free period (June 9–22, 2026) to evaluate Fable 5 on your codebase
• Set up Claude Code with the configuration examples above
• Start with a medium-complexity refactor to gauge costs and quality
• Build a model routing strategy for your team

Related:

• Claude Fable 5 Mythos 5 Analysis 2026 06 10 — Technical deep-dive on Fable 5's architecture
• Howto Aws Ecs Express Mode — Deploying AI-powered development environments on AWS