Sonnet 5.5 cache reads just halved, but idle gaps still decide your bill

Sonnet 5.5 prompt-cache reads now cost $0.10 per million tokens, half the $0.20 they cost before. Anthropic’s API release notes date the cut to 7 October 2026, and say cache writes and every other price stayed where they were. Claude Code 2.1.296 picked up the new figure in its cost display.

Cache reads are the line item that dominates a long agent session, so a halving matters. It just doesn’t matter as much as the headline suggests, because reads are only one of three things that fill the bill. The other two are output tokens and cache writes, and one setting controls whether you pay for the second one repeatedly.

What the price table says now

All figures are per million tokens, from Anthropic’s pricing page.

Two things stand out. Sonnet 5.5 and Opus 5.5 read from cache at 0.05 times the input price, where older models use 0.1. And Fable 5.1 reads at 0.025 times, a quarter of what Fable 5 charges. If the model is Fable, the cache discount is where the money is.

(Opus 5.5’s wider price cut is covered in this earlier piece . This one is about the cache lines only.)

A cost model for 40 turns

A coding agent resends the whole conversation on every request. Each turn pays to read the cached history, to write the new tokens onto the end of it, and to generate output. So the arithmetic is simple enough to script.

The script below models one session. It starts at 30,000 tokens of context (system prompt, CLAUDE.md, a few file reads), adds 2,000 new tokens per turn from tool results, and has the model write 1,000 output tokens per turn. These are assumptions, not measurements, so swap in your own numbers. Python, standard library only.

PRICES = {  # base input, 5m write, 1h write, cache read, output (USD per MTok)
    "sonnet-5":   (2.00, 2.50, 4.00, 0.20, 10.0),
    "sonnet-5.5": (2.00, 2.50, 4.00, 0.10, 10.0),
    "opus-5.5":   (4.00, 5.00, 8.00, 0.20, 20.0),
    "fable-5":    (10.0, 12.5, 20.0, 1.00, 50.0),
    "fable-5.1":  (10.0, 12.5, 20.0, 0.25, 50.0),
}
START, STEP, OUT, TURNS = 30_000, 2_000, 1_000, 40
GAPS = {12, 24, 33}  # turns that follow a break longer than 5 minutes

def session(model, ttl="5m", gaps=frozenset()):
    _, w5, w1, read, out = PRICES[model]
    write = w5 if ttl == "5m" else w1
    ctx, total = 0, 0.0
    for t in range(TURNS):
        new = START if t == 0 else STEP + OUT  # last turn's output joins the prefix
        cached = 0 if (t in gaps and ttl == "5m") else ctx
        total += cached * read / 1e6 + (new + ctx - cached) * write / 1e6 + OUT * out / 1e6
        ctx += new
    return total, ctx

Run it with no breaks and it prints:

40 turns, no breaks
  sonnet-5    $ 1.45
  sonnet-5.5  $ 1.11
  opus-5.5    $ 2.21
  fable-5     $ 7.23
  fable-5.1   $ 4.69
  final context: 147,000 tokens

The cut takes a Sonnet session from $1.45 to $1.11. That’s under a quarter off, not a half. Of the $1.11, cache reads are $0.34 (they were $0.68), cache writes are $0.37 and output is $0.40. Only the first of those moved. Fable 5.1 shows the larger effect: $7.23 down to $4.69 from the cache line alone.

On Sonnet 5.5 in this model, output is now the biggest single line, ahead of reads. A tighter plan or a smaller diff cuts that line directly.

Idle gaps cost more than the price cut saves

Now add the thing the price table can’t show. A cached prefix expires after a period of inactivity, and the next request after that has to write the whole history again at the write price. The same script, with three breaks longer than five minutes at turns 12, 24 and 33, prints:

Sonnet 5.5, three breaks longer than 5 minutes
  5m TTL: $1.80
  1h TTL: $1.33

Sonnet 5.5, no breaks
  5m TTL: $1.11
  1h TTL: $1.33

Three coffee breaks add 69 cents to a $1.11 session, twice what the cache-read cut saved on the whole run. A one-hour TTL absorbs them, but costs 22 cents more when there are no breaks, because every write is priced at 2 times input instead of 1.25. In this model each break costs about 23 cents, so the one-hour TTL pays for itself at roughly one break per session. The exact point depends on how much context you carry when the break happens, so measure rather than guess.

Which TTL you actually have

Claude Code decides the TTL per request, and the defaults differ by how you pay. According to the Claude Code docs, the main conversation gets a one-hour TTL only on a subscription within plan usage. With an API key, a cloud provider, or a subscription that has spilled into usage credits, it gets five minutes.

Subagents, workflows, in-process teammates, forks and compaction sit in a second bucket that gets five minutes everywhere, subscription included, unless you choose otherwise. That’s the bucket a fan-out of parallel agents lives in. If you run those with long-running tool calls, each agent’s cache can lapse mid-task.

API-key users who step away from sessions can opt in. Both settings take 5m or 1h, and need Claude Code v2.1.242 or later:

{
  "promptCacheTtl": "1h",
  "subagentPromptCacheTtl": "5m"
}

The same controls exist as the environment variables CLAUDE_CODE_PROMPT_CACHE_TTL and CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL. That snippet is the documented syntax, not something run for this article. The one-hour TTL makes sense for the main conversation if you leave sessions open while reviewing diffs. The subagent bucket is a judgement call: a subagent that works for two minutes and dies never benefits from the longer lifetime, and pays double for its writes.

Check before changing anything

Two documented checks tell you whether a change is worth making.

First, /usage in Claude Code 2.1.251 or later adds a Prompt cache (main) line showing the request count, the share of input tokens served from cache, the misses, and whether the cache is warm, with the TTL in effect. A cold-cache line after you come back from lunch is the pattern the numbers above describe. It covers the main conversation only, not subagents.

Second, to see which TTL your writes used, run claude -p "hello" --output-format json and read usage.cache_creation. Writes show up under ephemeral_1h_input_tokens or ephemeral_5m_input_tokens. If everything lands in the 5m field and you routinely leave sessions idle, the opt-in is worth trying.

The docs also list what throws away a warm cache on purpose: switching models with /model, since each model keeps its own cache, plus toggling fast mode, adding or removing an MCP server when its tools load up front, and compacting. Pick the model at the top of the session and leave it. Subagents on a cheaper model are the exception; they run in their own conversation and don’t disturb the parent’s cache.

What not to conclude

The model above is a model. Real sessions vary in how much each tool result adds, and a session that reads large files early carries a bigger prefix for longer. A cheaper cache read doesn’t change the case for keeping context small: the agent still reads the whole history on every turn, and a smaller history is cheaper at any price.

Subscription users on Pro, Max, Team or Enterprise plans draw on a seat allowance rather than paying per token, so the dollar figures here describe API and cloud-provider billing.

One thing to try today: run /usage at the end of a real session and compare the miss count to the number of times you stepped away. If those match, the TTL is the lever to pull.