Claude Fable 5

How to Get Started with Claude Fable 5

Claude Fable 5 is available via the Anthropic Claude API, Claude Platform on AWS, Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry. To start, create an account at platform.claude.com, generate an API key from the Console, and make your first request using the model ID claude-fable-5.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Summarize the key risks in this contract."}
    ],
)
print(response.content[0].text)

The model is available in the same SDKs used for all Claude models: TypeScript, Python, Go, Java, C#, PHP, and Ruby, as well as raw HTTP.

Understanding the Effort Parameter

Claude Fable 5 uses adaptive thinking as its only reasoning mode — the model decides when and how much to think based on each request. You control that depth using the effort parameter rather than manually setting token budgets.

The default is high. Set it explicitly for any workload where cost or latency matters:

response = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    output_config={"effort": "medium"},
    messages=[{"role": "user", "content": "Your prompt here"}],
)

For long-running agentic tasks at xhigh or max, set a large max_tokens — starting at 64k is a reasonable default — so the model has room to reason and call tools across multiple steps.

The effort parameter affects all token spend: text responses, tool calls, and thinking. Lower effort causes the model to make fewer tool calls, skip preambles, and produce more concise outputs. Higher effort produces more thorough tool use, detailed planning, and comprehensive code comments.

Working with the 1M Token Context Window

Claude Fable 5 supports a 1 million token context window at standard per-token pricing — no surcharge for large context. This enables workflows that previously required chunking or retrieval-augmented generation:

• Pass an entire codebase as context for architecture review or refactoring
• Load full legal agreements or regulatory documents for clause-level analysis
• Maintain complete conversation history across long agentic sessions without summarization
• Process multi-document research sets in a single inference call

The 128k output token limit per synchronous request supports generating complete module implementations, detailed reports, and structured data outputs in one call.

For very long sessions, use compaction to reduce token accumulation costs, and context editing (beta, via the context-management-2025-06-27 header) to clear tool results that are no longer needed in the active context.

How Refusals Work and How to Handle Them

Claude Fable 5 includes safety classifiers that can decline certain requests. A refusal is not an HTTP error — it returns a normal 200 response with stop_reason: "refusal":

{
  "stop_reason": "refusal",
  "stop_details": {
    "type": "refusal",
    "category": "cyber",
    "explanation": "This request was declined because it could enable cyber harm."
  },
  "usage": {
    "input_tokens": 412,
    "output_tokens": 0
  }
}

The stop_details.category field identifies which classifier fired. Defined categories are cyber (requests that could enable cyberattacks), bio (requests that could enable biological harm), and reasoning_extraction (requests asking the model to reproduce its internal chain of thought). The explanation field is human-readable but not stable — display it rather than parse it.

Requests refused before any output is generated are not billed.

Setting Up Automatic Fallback

Most requests that Claude Fable 5 declines can be served by another Claude model. The simplest approach is server-side fallback — pass the fallbacks parameter and the API retries automatically:

response = client.beta.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Your prompt here"}],
    fallbacks=[{"model": "claude-opus-4-8"}],
    betas=["server-side-fallback-2026-06-01"],
)

You receive one response. The model field in the response names whichever model actually served the reply. Server-side fallback is available on the Claude API and Claude Platform on AWS. For Amazon Bedrock, Vertex AI, and Microsoft Foundry, use the SDK middleware instead:

from anthropic import Anthropic
from anthropic.lib.beta import BetaRefusalFallbackMiddleware, BetaFallbackState

client = Anthropic(
    middleware=[BetaRefusalFallbackMiddleware([{"model": "claude-opus-4-8"}])],
)

state = BetaFallbackState()

with state:
    message = client.beta.messages.create(
        max_tokens=1024,
        model="claude-fable-5",
        messages=[{"role": "user", "content": "Your prompt here"}],
    )

The middleware handles retries automatically on any platform and pins follow-up turns in a conversation to the model that accepted the first request.

Key Pitfalls to Avoid

• Always retry on a different model — re-sending a refused request to Claude Fable 5 will produce another refusal
• Branch on stop_reason == "refusal" directly, not on stop_details (which can be null)
• Refusals return HTTP 200, so standard error rate monitoring never sees them — instrument them separately
• Configure fallback on every request path including retry handlers, background workers, and sub-agent calls

Prompt Caching to Reduce Costs

For workloads with repeated system prompts, large static documents, or shared context across many requests, prompt caching significantly reduces input token costs.

A cache read costs 10% of the standard input rate, meaning a 5-minute cache pays for itself after one cache read, and a 1-hour cache after two reads. Prompt caching can be combined with batch processing for maximum cost reduction on high-volume asynchronous workloads.

Batch Processing for High-Volume Workloads

The Message Batches API processes large volumes of requests asynchronously at 50% off both input and output token rates:

• Standard: $10 input / $50 output per million tokens
• Batch: $5 input / $25 output per million tokens

Batch mode is well-suited for document processing pipelines, bulk analysis tasks, and offline research workflows where response latency is not a constraint. Note that server-side fallback is not available in batch mode — refused batch items should be collected from results and resubmitted to a fallback model as a new batch.

Data Residency and Compliance

For organizations with data residency requirements, the inference_geo: "us" parameter on the Claude API and Claude Platform on AWS guarantees US-only inference routing at a 1.1x pricing multiplier across all token categories. Global routing is the default and uses standard pricing.

Claude Fable 5 is a Covered Model with 30-day mandatory data retention. Zero data retention is not available for this model. Organizations that require ZDR for all workloads should evaluate whether Claude Fable 5 fits their compliance posture before deployment.

Top 6 Use Cases of Claude Fable 5

1. Autonomous code review and software engineering across full repositories using 1M token context
2. Legal and compliance document analysis requiring full corpus context in a single session
3. Financial research synthesis from earnings reports, filings, and multi-source data into structured outputs
4. Multi-agent AI pipeline orchestration with structured refusal handling and automatic model fallback
5. Technical due diligence for M&A and vendor assessments involving large codebases or documentation sets
6. Scientific literature synthesis and hypothesis generation across large research corpora

Useful Links

• Models overview and specs
• Effort parameter reference
• Adaptive thinking guide
• Refusals and fallback
• Pricing reference
• Migration guide from Claude Opus 4.8
• Fallback and billing cookbook