Claude Fable 5

claude-fable-5

Claude Fable 5 is Anthropic's Mythos-tier model, built for autonomous knowledge work and coding. It supports text, image, and file inputs as well as text output, with reasoning support and a 1M token context window. It is suited for long-running, complex, and asynchronous tasks that previously required frequent human check-ins. It is especially powerful in end-to-end work that would otherwise require a person to spend hours, days, or weeks solving long-running, ambiguous, or highly multi-step problems. It performs a broad range of tasks with few errors, automatically self-corrects through verification loops, and is equipped with strong safeguards.

Context window1.0M

ProviderClaude

Released2026/06/10

Playground

Pricing

The same model is available through multiple service channels — choose based on latency, reliability and cost.

Prices in $ / 1M tokens

To pick a channel, add a provider field to the request body, for example "provider": { "channel": "direct" }. Valid values are direct / stable / economical; omit it to use the default channel.

Direct

Direct upstream connection — best when you need native behavior and the full context window.

Input	Output	Cache read	Cache write
10.00/M	50.00/M	1.00/M	12.50/M

5% off

Preferred

A balanced route optimized for availability and speed — a good default for production traffic.

Input	Output	Cache read	Cache write
10.009.50/M	50.0047.50/M	1.000.95/M	12.5011.88/M

Overview

Input

Text Image

Output

Text

Claude Fable 5 API: Mythos-Level Model for Autonomous Knowledge Work

Claude Fable 5 is Anthropic's strongest publicly released model, in the Mythos tier, built specifically for autonomous knowledge work and long-horizon coding. It supports text, image, and file inputs, offers a 1M token context window, and thinking is always on — it neither requires nor allows manual configuration of a thinking budget.

Fable 5's real difference lies in its ability to take on work that previously required constant human intervention: asynchronous tasks running for hours or even days, end-to-end system implementations, and deep research across massive amounts of material. On such tasks, it can push through to the final step more reliably than any Opus-tier model.

SeaWhale AI provides Fable 5 through the Anthropic native Messages API, with support for reasoning Effort control, task budgets, context compaction, and full tool calling.

Get API Key · Model ID: claude-fable-5

Why Choose Claude Fable 5

Strongest publicly released Claude model — Built for the most demanding reasoning and long-horizon agentic tasks
Thinking always on — No thinking budget configuration needed; just control depth with output_config.effort
Single requests can run for minutes — On hard tasks, a single call gathers context, builds, verifies, and delivers on its own
1M token context — Entire codebases and massive research materials fit in one pass
Reliable parallel subagent collaboration — Maintains continuous communication with long-running subagents without suppressing delegation

Core Capabilities

01 Long-Horizon Autonomous Execution

Fable 5's greatest value lies in work beyond the capability boundaries of previous models: overnight coding tasks, one-shot implementations of well-specified systems, and end-to-end enterprise-grade deliverables. Provide sufficient upfront instructions and let it run to completion.

Hours-long autonomous coding and refactoring
System-level implementations completed on the first pass
End-to-end production of financial analysis, spreadsheets, slides, and documents

02 Five-Level Reasoning Effort

The five levels from low to max are the primary intelligence/latency/cost controller. Even at lower levels, Fable 5 often exceeds the previous generation's xhigh performance, so everyday tasks don't require higher levels.

high for routine tasks, xhigh / max for the most demanding scenarios
low / medium still perform excellently on Fable 5
Pair with task budgets to control the total spend of agent loops

03 Code Review, Debugging, and Repository History Search

High recall and precision in real-world defect discovery. It can pinpoint intermittent flaky tests rather than declaring a fix after one passing run, and it is also good at searching repository history for clues.

High-precision, high-recall defect discovery
Localization of intermittent failures and hidden edge cases
Repository history and commit chain search

04 Vision and Multi-Agent Collaboration

Specifically trained on degraded images such as rotated, blurry, and noisy inputs, it proactively uses bash and cropping tools to analyze and verify repeatedly. It also coordinates multiple subagents stably, and the writer-verifier pattern works well.

Iterative analysis of dense charts and degraded images
Parallel subagent delegation and asynchronous collaboration
Self-verification and result cross-checking in long tasks

Best Use Cases

Use Case	Description
Overnight autonomous coding	Launch with a single instruction and complete complex refactoring or full feature implementations
Deep research	Comprehensive analysis across large volumes of papers, reports, and policy documents
Enterprise-grade deliverables	Financial models, multi-sheet workbooks, presentations, and research briefs
Code review and debugging	High-recall defect discovery, root cause localization, flaky test investigation
Multi-agent orchestration	Coordinate parallel subagents and converge asynchronously to final deliverables
High-difficulty vision tasks	Iterative parsing of degraded images, dense charts, and technical drawings

Claude Fable 5 vs. Claude Opus 5 and Opus 4.8

Capability	Claude Fable 5	Claude Opus 4.8	Claude Sonnet 5
Model ID	`claude-fable-5`	`claude-opus-4-8`	`claude-sonnet-5`
Positioning	Strongest publicly released model	Flagship long-horizon agent	Balance of speed and intelligence
Thinking mode	Always on, cannot be disabled	Adaptive, can be disabled	Adaptive, on by default
Context window	1M token	1M token	1M token
Max output	128K token	128K token	128K token
Single task duration	Up to several minutes	Minute-level	Shorter
Best for	Hardest, longest autonomous tasks	Everyday flagship agentic work	Large-scale production workloads

Actual billing is subject to the real-time price card at the top of the page.

How to Use the Claude Fable 5 API

1. Create a SeaWhale AI API key Generate a key in the console and top up your balance.

2. Do not configure the thinking parameter Fable 5's thinking is always on; explicitly passing {"type": "disabled"} or budget_tokens will be rejected. Use output_config.effort to control depth.

3. Make a request

curl -X POST https://api.seawhaleai.com/v1/messages \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "claude-fable-5",
    "max_tokens": 32000,
    "output_config": {"effort": "high"},
    "stream": true,
    "messages": [
      {"role": "user", "content": "Read this requirements document, implement the complete server, and write your own tests to verify."}
    ]
  }'

For long tasks, it is recommended to enable streaming to avoid request timeouts.

FAQ

What is the difference between Claude Fable 5 and the Opus tier? Fable 5 is Mythos-tier, with capabilities above Opus and a higher price. Its advantages are concentrated on the hardest, longest, and most autonomy-demanding tasks; for everyday work, Opus or Sonnet is more cost-effective.

Why can't thinking be disabled? Fable 5's thinking capability is part of the model itself and is always on. The correct way to save tokens is to lower effort, not to disable thinking.

Can I get the raw content of the thinking? No. The raw chain of thought is never returned; you can only get a readable summary via display: "summarized".

How long does a single request take? On hard tasks, a single call running for over ten minutes is normal. Plan properly for timeouts, streaming, and progress indicators so users can view results asynchronously.

Do prompts need to be rewritten? Step-by-step scaffolding written for older models tends to be overly prescriptive and actually lowers Fable 5's output quality. It is recommended to remove it and run A/B comparisons, prioritizing goals and constraints over enumerated steps.

What capabilities are supported? Effort control, task budgets, context compaction, memory tools, tool-call cleanup, and high-resolution vision are all supported.

Why Use Claude Fable 5 API on SeaWhale AI

Native Messages API — Full passthrough of thinking, caching, task budgets, and beta features
No self-built proxy needed — Direct connection in China, with stability and latency guaranteed by the platform side
Pay-as-you-go billing — Pay only for actual usage, with no minimum spend threshold
One key for multiple models — Use Fable 5 for hard tasks, switch to Opus or Sonnet for routine work, all under the same account

API

API integration

Model IDUse this value as the model in inference requests

claude-fable-5

API KeyBearer token used to authenticate inference requests

Manage API keys

Base URLOpenAI compatible · /chat/completions

https://api.seawhaleai.com/v2/

provider OptionalSelects a service channel; omit it and the system picks the default

"provider": { "channel": "direct" }

claude-fable-5 usage examples

SeaWhale AI is compatible with the OpenAI API protocol, so you can call it with the OpenAI SDK or plain HTTP requests. Streaming is enabled by default.

About the provider parameter (optional, a SeaWhale AI extension): most models are served over several channels that differ slightly in price and reliability. Add a provider field to the request body to pick one; omit it and the system selects the default channel — normal calls are unaffected.

provider is not part of the official OpenAI protocol — it is a SeaWhale AI extension that only takes effect on this platform. The OpenAI SDK allows custom fields like this to pass through; see the examples below.

Value	Channel	Best for
`direct`	Direct	The official upstream link, for native behavior and the full context window
`stable`	Preferred	Balanced availability and speed — a good default for production traffic
`economical`	Economy	Cost first, well suited to batch processing and price-sensitive workloads

Available channels and their prices are listed under "Pricing" above (channels vary by model). Additional notes:

Syntax: "provider": { "channel": "direct" }.
If the requested channel is not enabled for that model, the request automatically falls back to the default channel and returns normally — it does not error.
With the official SDKs: in Python pass it via extra_body; in Node.js put it directly on the request object and it passes through. In TypeScript projects, add a // @ts-expect-error line to skip the type check.

cURLPythonNode.js

curl https://api.seawhaleai.com/v2/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <API_KEY>" \
  -d '{
    "model": "claude-fable-5",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    "provider": { "channel": "direct" },
    "stream": true
  }'
# provider is optional — remove this line to use the default channel

from openai import OpenAI

client = OpenAI(
    base_url="https://api.seawhaleai.com/v2",
    api_key="<API_KEY>",
)

stream = client.chat.completions.create(
    model="claude-fable-5",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"},
    ],
    stream=True,
    # Optional: pick a service channel; omit to use the default
    extra_body={"provider": {"channel": "direct"}},
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import OpenAI from 'openai'

const client = new OpenAI({
  baseURL: 'https://api.seawhaleai.com/v2',
  apiKey: '<API_KEY>',
})

const stream = await client.chat.completions.create({
  model: 'claude-fable-5',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Hello!' },
  ],
  stream: true,
  // Optional: pick a service channel; omit to use the default
  // @ts-expect-error provider is a SeaWhale AI extension, not in the OpenAI SDK types
  provider: { channel: 'direct' },
})

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '')
}