Cut your Claude bill: make cache reads, not writes, carry the load

Look at the cache line items on your Claude bill. In one reported $1,023.78 Claude bill, cache writes were 9.4% of tokens and 65.8% of cost, while cache reads were 89.8% of tokens and 12.6% of cost. Claude Fable 5.1 trades write churn against read reuse. Anthropic released Claude Fable 5.1 and Mythos 5.1 on September 1, and cut Fable 5.1 cache reads from $1.00 to $0.25 per million tokens, a 75% cut. Fable 5.1 kept input pricing at $10 per million tokens and output pricing at $50 per million tokens, while cache-write pricing stayed at $1.25 per million for five-minute caches and $2.00 per million for one-hour caches. One write token therefore costs five to eight times one read token.

Reads are the cheap path, writes are the tax

The price cut makes read reuse the main cost lever. A request that reuses a stable prefix pays a low marginal cost. A changed prefix makes the system pay the write price again. A stable prefix is the unit of reuse: leading-byte changes make the cache treat the rest as new, so tool order, system prompt version, and example order matter. Write decisions are the main cost control, not read decisions.

Anthropic's August usage data showed the cache-read cut produced about 25% savings on typical workloads and up to about 45% savings on agentic workloads. That range is the target, not a guarantee. Read reuse drives the difference.

Build the prefix so the cache actually hits

The checklist below is the control surface. Each item is a quick test, not a project. It targets the write-to-read ratio that decides whether the $0.25 read price shows up on the invoice.

• Put the system prompt, tool schemas, and static examples in the leading block of the request, and never reorder them.
• Set the cache breakpoint at the end of that stable block, then confirm the next request returns a cache read.
• Set a read-hit target for each route, then log the current ratio next to it.
• Use five-minute TTL for bursty traffic and one-hour TTL only when the same prefix recurs within an hour.
• Audit the bill line items and compare write token share to write cost share.
• Invalidate by version, not by timestamp: bump a prefix hash when behavior changes.
• For agents, keep the conversation tail outside the cached prefix and cache only the stable tool and policy context.
• Monitor write tokens per request and reads per session; a rising write-per-request ratio is a cache miss.

Some items protect the prefix. Others protect the TTL and invalidation path. The final items make the result visible. The bill audit is the check that survives refactors. Token counts can look healthy while cost climbs because the mix shifts toward writes. Line items should answer one question: is the system paying for the same context more than once?

Fable 5.1 applies prefix binding to accounts created on or after August 31, 2026, so changes to earlier context void later thinking blocks; Mythos 5.1 skips that validation. Fable 5.1 made forced tool use return a 400 error and limited Fable 5.1 thinking blocks to Fable 5.1 and Mythos 5.1 readers. Those constraints shape the prefix, not just the prompt.

Make the bill prove the architecture

Agent workload cost is where the architecture shows up. A loop that rewrites the system prompt, reorders tools, or appends volatile context before the breakpoint keeps paying write prices. The bill should show reads as the large token share and writes as the small cost share. Writes that still dominate cost mean the prefix is moving, the TTL is wrong, or the agent is rewriting context every turn. Compare the next bill against the previous one.

Agentic loops are the hardest case because the model may change the context it needs. Stable context covers the policy, tool schema, and task frame. Volatile context covers the latest observation, tool result, and plan. Keep volatile context after the breakpoint. Agent rewrites of the stable part stop the cache read path.