Claude Fable 5: A Clear-Eyed Look at Anthropic's New Flagship Model

Anthropic has shipped a new top-of-the-line model, and for the first time since 2023 it does not slot into the Haiku, Sonnet, Opus ladder. It sits above it. Claude Fable 5 (model ID claude-fable-5) is a new tier with a new name, a doubled price tag, and a noticeably stricter API surface. The launch material calls it the most intelligent Claude yet, which is what every launch material says, so in this post I want to do something more useful: lay out exactly what changed against the Opus 4.x family, show you the code that breaks and the code that replaces it, and give you a small harness so you can measure whether the upgrade earns its price on your workload rather than on someone else's benchmark slide.

Anthropic's Claude family now spans four names: Haiku, Sonnet, Opus, and Fable.

A fourth name, and why it sounds different

Anthropic's model names have always been a quiet size joke. A haiku is seventeen syllables, a sonnet is fourteen lines, an opus is a full-scale composed work. Small, medium, large, told through literary forms. Fable continues the literary theme but changes its meaning: a fable is not defined by length at all, it is defined by carrying a point. Whether that was the intent or just a nice accident, the name lands differently. Haiku, Sonnet, and Opus sound like formats; Fable sounds like a storyteller. Say it out loud and it is soft and rounded where Opus is punchy, which fits a model Anthropic describes as having a warmer, clearer writing voice than the deliberately clipped Opus 4.7 era.

The version number is the other tell. This is not Opus 4.9 or Opus 5. By jumping to a fresh name with a 5 attached, Anthropic is signalling a new top tier rather than an increment, the same way the jump from Claude 2 to the three-name Claude 3 family signalled a strategy change back in early 2024. Opus does not go away. Opus 4.8 remains in the lineup at its existing price, which makes this less of a replacement and more of a new ceiling, and that framing matters when we get to cost.

The headline numbers, side by side

Specs first, because most upgrade decisions die or survive on this table. Context window and output ceiling are unchanged from Opus 4.8. The two things that actually move are the price, which doubles, and the API surface, which tightens.

One detail worth pausing on: the 1M token context window comes at standard pricing. There is no long-context surcharge, which used to be the catch with very large windows. If your pipeline regularly stuffs hundreds of thousands of tokens of code or documents into a single request, the effective price gap versus Opus narrows, because you are paying for capability you actually use rather than a premium for the privilege.

Your first Fable 5 request

Getting a response out of Fable 5 looks almost identical to Opus 4.8, which is deliberate: the request surface is the same one Opus 4.7 introduced. The two habits worth building from day one are turning adaptive thinking on explicitly (it is not on when the field is omitted) and streaming anything with a large max_tokens, because a 128K output ceiling will blow through HTTP timeouts on a plain request.

# first_request.py
# pip install anthropic
from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment

with client.messages.stream(
    model="claude-fable-5",
    max_tokens=64000,
    thinking={"type": "adaptive"},          # not on by default; set it explicitly
    output_config={"effort": "high"},       # low | medium | high | xhigh | max
    system="You are a senior engineer doing a design review. "
           "Be specific and name the trade-offs.",
    messages=[{
        "role": "user",
        "content": "Review this plan: we want to move our monolith's reporting "
                   "queries to a read replica while writes stay on the primary. "
                   "What breaks first, and how do we detect it before users do?",
    }],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

message = stream.get_final_message()
print(f"\n\n[stop: {message.stop_reason}, "
      f"output tokens: {message.usage.output_tokens}]")

The effort parameter is doing more work here than it looks. It controls how deeply the model thinks and how many tokens it is willing to spend across a task, from low for quick scoped answers up to max for problems where correctness beats cost. On this model generation, effort is the dial that replaced the old token budgets, and Anthropic's own guidance is to start at high and sweep up or down on your own evals instead of reflexively maxing it out.

The API got stricter, and your old code will 400

This is the part that bites during migration. The Opus 4.7 generation already removed sampling parameters and manual thinking budgets, and Fable 5 adds one more restriction of its own: you can no longer send an explicit thinking: {"type": "disabled"}. On Opus 4.8 that is accepted; on Fable 5 it returns a 400, and the only way to run without thinking is to omit the field entirely. In practice the philosophy is clear, Anthropic wants prompting to be the steering wheel and is removing every numeric knob that used to compete with it. Whether you find that liberating or annoying probably depends on how much tooling you built around temperature.

# migration_check.py
# Three request shapes that worked on older Claude models and now fail.
import anthropic

client = anthropic.Anthropic()

broken = [
    {"temperature": 0.7},                                      # removed entirely
    {"thinking": {"type": "enabled", "budget_tokens": 8000}},  # manual budgets gone
    {"thinking": {"type": "disabled"}},  # fine on Opus 4.8, rejected on Fable 5
]

for params in broken:
    try:
        client.messages.create(
            model="claude-fable-5",
            max_tokens=1024,
            messages=[{"role": "user", "content": "Say hi"}],
            **params,
        )
    except anthropic.BadRequestError as err:
        print(f"rejected {list(params)[0]!r}: {err.message[:80]}")

# The shape that works: adaptive thinking on, every legacy knob deleted.
response = client.messages.create(
    model="claude-fable-5",
    max_tokens=1024,
    thinking={"type": "adaptive"},
    messages=[{"role": "user", "content": "Say hi"}],
)
print(response.content[0].text)

Is it actually better? Measure it on your own work

Here is where I want to take the middle ground seriously. Anthropic positions Fable 5 as its most capable model, and based on the lineage that is plausible: each Opus 4.x release genuinely did improve long-horizon agentic work, bug-finding, and instruction following. But "most capable" and "worth 2x per token for your use case" are different claims, and at launch you will mostly be reading first-party numbers. The honest move is to run your own prompts through the tiers and look at three columns: quality you can judge, latency you can feel, and cost you can calculate. This little harness does the boring parts.

# compare_models.py
# Same prompt, three tiers, real latency and cost from your own workload.
import time
from anthropic import Anthropic

client = Anthropic()

PRICES = {  # USD per million tokens: (input, output)
    "claude-fable-5":    (10.00, 50.00),
    "claude-opus-4-8":   (5.00, 25.00),
    "claude-sonnet-4-6": (3.00, 15.00),
}

PROMPT = """You are reviewing a pull request that changes our retry logic.
Find the bug in this snippet and propose a minimal fix:

async def fetch_with_retry(url, retries=3):
    for attempt in range(retries):
        try:
            return await http.get(url)
        except TimeoutError:
            await asyncio.sleep(2 ** attempt)
    raise RuntimeError("unreachable")
"""

def run(model: str) -> None:
    start = time.monotonic()
    response = client.messages.create(
        model=model,
        max_tokens=16000,
        thinking={"type": "adaptive"},
        output_config={"effort": "high"},
        messages=[{"role": "user", "content": PROMPT}],
    )
    elapsed = time.monotonic() - start
    u = response.usage
    in_price, out_price = PRICES[model]
    cost = (u.input_tokens * in_price + u.output_tokens * out_price) / 1_000_000
    print(f"{model:22} {elapsed:6.1f}s  in={u.input_tokens:<6} "
          f"out={u.output_tokens:<6} cost=${cost:.4f}")
    print(response.content[-1].text[:200], "\n")

for model in PRICES:
    run(model)

Run it with ten of your real prompts instead of my toy one and you will learn more than any launch post can tell you. A pattern worth watching for: on hard agentic tasks, a smarter model at higher effort sometimes finishes in fewer turns and fewer total tokens, which can partially or fully cancel the per-token premium. On simple extraction and classification, it almost never will, and Sonnet 4.6 at a fifth of the output price will quietly embarrass the flagship on cost per result.

What it knows, and the cutoff question

Fable 5 ships with a knowledge cutoff of January 2026, which means its training data includes events, libraries, and releases up to the start of this year. That is a practical difference, not a cosmetic one. Models with older snapshots have to burn a web search round-trip to know about a framework released last autumn; a model whose training already includes late 2025 answers those questions natively, faster, and without the failure modes of search. The flip side deserves equal weight: a cutoff is a hard wall, the model has no idea it is standing next to one unless asked carefully, and anything that happened after January is invisible to it. For current-events workloads you still want the web search tool wired in, whatever the cutoff says.

You do not have to memorise any of these specs either, because the Models API will tell you what a model supports at runtime. This is the right way to build capability checks into a pipeline that might run against several Claude versions.

# capabilities.py
# Ask the API what claude-fable-5 can do instead of hardcoding assumptions.
from anthropic import Anthropic

client = Anthropic()

m = client.models.retrieve("claude-fable-5")
print(m.display_name)       # Claude Fable 5
print(m.max_input_tokens)   # 1,000,000 token context window
print(m.max_tokens)         # 128,000 max output tokens

caps = m.capabilities
print(caps["thinking"]["types"]["adaptive"]["supported"])  # True
print(caps["thinking"]["types"]["enabled"]["supported"])   # False: no budgets
print(caps["effort"]["max"]["supported"])                  # True
print(caps["structured_outputs"]["supported"])             # True

# Which models in your org support adaptive thinking with a 1M window?
for model in client.models.list():
    if (model.capabilities["thinking"]["types"]["adaptive"]["supported"]
            and model.max_input_tokens >= 1_000_000):
        print(model.id)

The pricing question nobody can dodge

At $10 in and $50 out, Fable 5 is the most expensive Claude ever sold through the API, and the gap to its own sibling is the story: double Opus 4.8 on both sides of the meter. To make that concrete, an agent run that consumes 200K input tokens and produces 30K output tokens costs about $3.50 on Fable 5 versus $1.75 on Opus 4.8 and $1.05 on Sonnet 4.6. Multiply by a few thousand runs a month and the model choice becomes a budget line, not a dropdown.

My honest read: this launch is aimed at the workloads where model quality is the bottleneck, overnight coding agents, deep research, complex multi-step pipelines where a single wrong turn wastes an hour of compute. If that is you, the premium probably pays for itself and you should test seriously. If your traffic is summaries, lookups, and structured extraction, nothing about this release changes the advice that Sonnet 4.6 is the value king and Haiku 4.5 the throughput king. A flagship existing does not obligate you to fly it.

# caching.py
# A stable prefix makes repeat requests ~90% cheaper on the cached portion.
response = client.messages.create(
    model="claude-fable-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    system=[{
        "type": "text",
        "text": LARGE_STYLE_GUIDE,   # stable content first, volatile last
        "cache_control": {"type": "ephemeral"},
    }],
    messages=[{"role": "user", "content": question}],
)

u = response.usage
print(u.cache_creation_input_tokens)  # first call: pays a ~1.25x write premium
print(u.cache_read_input_tokens)      # repeat calls: ~0.1x of the input price
print(u.input_tokens)                 # only the uncached remainder bills full

The verdict, such as it is

Fable 5 is a real step: a new tier, a tighter and more opinionated API, fresher knowledge, and by every early indication the strongest reasoning Anthropic has shipped. It is also twice the price of a model that was the flagship until yesterday and remains excellent today. Both things are true at once, and pretending otherwise in either direction is how teams end up overpaying or underperforming. Treat the launch as an invitation to measure, not a command to migrate. Run the comparison harness on your own prompts, check whether higher effort actually reduces your turn counts, cache your prefixes, and let the spreadsheet rather than the announcement decide which model ID goes in your config.