Claude Fable 5.1's 75% Cache-Read Cut: Rebuilding Your Agent Cost Model Around $0.25 Tokens

On September 1, 2026, Anthropic shipped Claude Fable 5.1 and Claude Mythos 5.1 together. The models themselves are strong: Fable 5.1 scores 52.6% on Terminal-Bench-Science 0.1, more than double Fable 5's 24.7%, and Mythos 5.1 reaches 60.9% on Terminal-Bench 4.0. But for most engineering teams the real news sits in the price sheet: Fable 5.1's headline input and output prices did not move, while prompt cache reads dropped from $1.00 to $0.25 per million tokens. Anthropic estimates real-world cost falls about 25% on typical workloads and up to 45% on heavily agentic ones. Why does a cache cut matter so much for agents? Because an agent loop re-reads its long system prompt and tool definitions on nearly every turn. This guide covers the new cache economics, when Fable 5.1 beats Opus 5 on cost, and how to reshape prompts and routing so your invoice actually reflects the cut.

1. What Shipped: A Model Upgrade Plus One Rewritten Price Line

Fable 5.1's sticker prices match Fable 5 exactly: $10 per million input tokens and $50 per million output, with cache writes unchanged at $12.50 for five minutes and $20 for one hour. The only change is cache reads, down from $1.00 to $0.25 per million tokens, the first time Anthropic has priced a cache multiplier this low: cache reads are now 2.5% of Fable 5.1's normal input price, versus the 10% multiplier used by most other Claude models. On benchmarks, Fable 5.1 scores 55.8% on Terminal-Bench 4.0 and Mythos 5.1 hits 60.9%, while Anthropic also reports improved safeguards that flag benign cybersecurity requests about 60% less often.

# Track the three line items that decide your bill after the cut.
# cache_read_tokens at $0.25/MTok now dominates the math for agent loops.
def invoice_math(uncached_input, cache_read, cache_write_5m, output):
    return {
        "uncached_input_usd": round(uncached_input * 10 / 1_000_000, 2),
        "cache_read_usd": round(cache_read * 0.25 / 1_000_000, 2),
        "cache_write_5m_usd": round(cache_write_5m * 12.50 / 1_000_000, 2),
        "output_usd": round(output * 50 / 1_000_000, 2)
    }

print(invoice_math(200_000, 12_000_000, 400_000, 300_000))

2. Why the Cache Cut Is the Biggest Win for Agent Loops

Agent loops differ from chat in one crucial way: repetition. Every tool-calling turn sends nearly the same system prompt, tool definitions, and conversation history back to the model. When the cache hits, that repeated prefix is billed at $0.25 per million tokens instead of $10. The higher your cache-read share, the bigger the cut lands, which is exactly why Anthropic can claim up to 45% savings on heavily agentic workloads. The reverse is also true: if cache reads are a tiny share of your bill, your prompts are changing every turn, and the first thing to optimize is not the model but the split between a stable prefix and a volatile tail.

# Restructure prompts so the stable prefix is big and the volatile tail is small.
STABLE_PREFIX = [
    {"role": "system", "content": SYSTEM_PROMPT},   # rarely changes
    {"role": "user", "content": TOOL_DEFINITIONS}, # grows, but stable
]

VOLATILE_TAIL = [
    {"role": "user", "content": f"Task: {task}"},
    {"role": "assistant", "content": f"Plan: {plan}"},
]

messages = STABLE_PREFIX + VOLATILE_TAIL
# Cache is keyed by exact token prefix: keep STABLE_PREFIX byte-identical
# between turns or you pay a cache write instead of a cache read.

3. Fable 5.1 Versus Opus 5: When Each One Wins on Cost

Fable 5.1's normal input price is twice Opus 5's ($10 versus $5), but its cache reads cost half as much ($0.25 versus $0.50). The rough crossover sits where cache reads make up roughly a third or more of your input-side bill, at which point Fable 5.1's total can come out ahead. Independent analysis reaches the same shape: Opus 5 stays cheaper below that crossover, and The Decoder's estimates put Fable 5.1 at about $3.76 per Intelligence Index task at max effort versus Opus 5's $2.34. The honest conclusion is not that Fable 5.1 is cheaper; it is that high-cache-hit agentic workloads are where Fable 5.1 earns its keep, and routing has to be built on your measured cache-hit ratio, not the sticker price.

# Choose cache duration from real pause patterns, not habit.
# 5-minute writes: $12.50/MTok. 1-hour writes: $20/MTok.
# If your agent pauses under ~5 min between turns, 5m wins on write cost.
import statistics

def pick_duration(inter_turn_gaps_min):
    median_gap = statistics.median(inter_turn_gaps_min)
    if median_gap < 4:
        return "5m"      # cheap writes, most turns re-read inside the window
    return "1h"          # long pauses make 1h cheaper overall

print(pick_duration([0.4, 0.8, 1.2, 6.0, 0.5]))

4. Restructuring Prompts Around the $0.25 Read

Caching is billed on an exact token prefix, so prompt structure decides whether you pay $0.25 or $10. Three rules matter in practice. First, put long, stable content, system prompts, tool definitions, and knowledge bases, in the stable prefix, and keep volatile content such as the task description in the tail. Second, keep that prefix byte-identical between turns: any tiny change invalidates the whole prefix and turns what should be a cheap read into an expensive write. Third, choose between the five-minute and one-hour caches from real pause patterns; when agent turns are seconds apart, the cheaper five-minute write usually wins.

5. Keep-Alive and Routing: Engineering Every Turn to Hit

Hit rate decides whether this price cut shows up on your invoice. For flows with longer pauses, a max_tokens=0 request on the unchanged prefix refreshes the TTL so a five-minute cache survives the whole task; for genuinely long jobs, plan for the one-hour cache. Write your routing layer as an explicit policy: heavy agentic traffic with a high cache ratio goes to Fable 5.1, low-reuse question-answering goes to Opus 5, and routine work stays on Sonnet 5. Do not configure routing by feel: run a week of real traffic, record the cache-read share per task type with a token counter, and only then pick your default model.

# Keep the cache warm: a max_tokens=0 request on the unchanged prefix.
def keep_alive(client, prefix):
    # Re-reads the cached prefix without generating output, refreshing TTL.
    return client.messages.create(
        model="claude-fable-5-1",
        max_tokens=0,
        messages=prefix,
        extra_headers={"anthropic-cache": "true"}
    )

6. A Landing Checklist

First, confirm your SDK and proxy layer actually enable prompt caching and pass cache headers through; many teams discover they were never caching at all. Second, audit prompt stability: move timestamps, random IDs, and other per-turn content out of the prefix. Third, upgrade cost monitoring from total tokens to four line items, uncached input, cache reads, cache writes, and output, because the effect of the cut only shows up in the breakdown. Fourth, validate cache hits in staging with an API tester before a full rollout. And remember: a vendor price cut is not permission to relax; teams that engineer for cache hits capture the full 45%, everyone else gets the base 25%.

# Route between Fable 5.1 and Opus 5 by your measured cache-hit ratio.
# Opus 5 input $5 / cache $0.50; Fable 5.1 input $10 / cache $0.25.
# If cache reads are more than ~1/3 of your input bill, Fable 5.1 can win.
def pick_model(cache_ratio, heavy_agentic=False):
    if heavy_agentic and cache_ratio > 0.35:
        return "claude-fable-5-1"   # 75% cheaper reads dominate
    if cache_ratio < 0.20:
        return "claude-opus-5"      # low reuse: base input price matters
    return "claude-sonnet-5"        # middle ground for routine work

print(pick_model(0.45, heavy_agentic=True))