Prompt Caching Economics: Designing Cache-First Agents

Prompt caching economics changed shape on July 9, 2026. When OpenAI moved GPT-5.6 to general availability, it didn't just ship a new model family — it replaced its free, implicit caching model with explicit breakpoints, a 1.25x cache-write premium, and a 30-minute minimum TTL. For anyone building multi-step agents, the question is no longer whether to cache; it's whether your architecture is designed to collect the discount.

If you need the fundamentals — what a cache hit is, how the discount math works, why prefix ordering matters — read our caching-mechanics primer from June first. This post is its architecture-design sequel, and it exists because the ground moved after that primer shipped: OpenAI's new write-premium model, Anthropic's breakpoint and lookback budgets, and DeepSeek's best-effort full-prefix matching each impose different operational constraints that a "put static content first" rule alone doesn't satisfy.

This guide covers the GPT-5.6 caching reset, a three-vendor comparison of the operational rules that determine real-world hit rates, breakeven math re-derived from the published multipliers, breakpoint budget management in long agent loops, and the model-homogeneous staging pattern — with a worked swap-tax calculation that puts the design principle in dollar terms.

Until this month, OpenAI's caching story was the simple one: implicit, automatic, free to write, 90% off on reads. GPT-5.6 — previewed June 26 and GA'd July 9, 2026 across the Sol, Terra, and Luna tiers — introduces a fundamentally different model for the new family. Three changes matter for agent builders, and together they move OpenAI's caching semantics much closer to Anthropic's.

The pricing card underneath is familiar: GPT-5.6 Sol runs $5 input / $30 output per million tokens with cached input at $0.50; Terra is $2.50 / $15 with cached input at $0.25; Luna is $1 / $6 with cached input at $0.10. The 90% read discount survives intact. What changed is that the discount now has a price of admission — you pay 25% extra to place content into cache, so a prefix that never gets re-read is a net loss, not a free option.

One more OpenAI change matters for agents on the older models: earlier this year, OpenAI moved default cache retention for GPT-5.5-and-earlier models in non-ZDR organizations to up to 24 hours, offloading KV tensors to GPU-local storage rather than the prior few-minutes-to-one-hour in-memory window. Longer retention means intermittent workloads — an agent invoked every 20 minutes, say — can now realistically hit cache between invocations on those models where they previously could not.

Most caching comparisons stop at the headline discount percentage. That is the least decision-relevant number on the page. The operational constraints — how many breakpoints you get, how far back the system looks for a match, how long entries live, and what counts as a match at all — are what determine whether a production agent actually collects the discount. The table below assembles those rules for Anthropic, OpenAI's GPT-5.6 family, and DeepSeek's V4 line side by side; we have not found this comparison published elsewhere. For base per-token rates across the wider market, see the Q2 2026 per-token pricing index.

Two hedges on the DeepSeek row. First, the headline discount: DeepSeek's own pricing table did not clearly break out a cache-hit discount at the time of writing — the rendered page showed identical hit and miss figures — while three independent pricing trackers agree on cache-hit input of $0.003625 per million tokens for V4-Pro against the $0.435 cache-miss rate, and $0.0028 against $0.14 for V4-Flash. Treat the ~98-99% figures as third-party-reported until DeepSeek's table is unambiguous. Second, those V4 list prices are themselves promotional — a 75% discount DeepSeek says adjusts upward after the promo window, which press coverage places around mid-July 2026. Teams still on the legacy deepseek-chat and deepseek-reasoner model names should also note both deprecate on July 24, 2026.

That sentence is the design constraint hiding inside DeepSeek's near-total discount: caching is best-effort, eviction is vague by specification, and only a full-prefix match from position zero counts. An agent that reorders context, interleaves per-user content early in the prompt, or lets sessions go cold for a day cannot budget around a guaranteed hit. The economics are spectacular when they land and unknowable in aggregate — which is why DeepSeek exposes per-request hit and miss token counts, covered in Section 07. The pattern extends beyond closed vendors, too: open-weight rental stacks now expose the same shape, with GLM-5.2 cached input on DeepInfra at $0.18 per million tokens against roughly $0.93-0.95 standard.

Write premiums sound scary; the arithmetic is friendlier than the framing. The numbers below are our own derivation from the published pricing multipliers — 1.25x writes, 0.1x reads — not vendor-published benchmarks, so check them against your own workload shape. On Anthropic's 5-minute tier (and identically on GPT-5.6), caching a prefix costs 0.25x extra once, and every subsequent read of that prefix saves 0.9x. The premium is therefore recovered after 0.25 divided by 0.9 — roughly 28% of one full re-read. If a cached prefix is read even once before its TTL lapses, caching wins.

The failure mode is the aggregate case. Under a write-on-every-miss policy, expected input cost per request is 1.25 times the base rate on misses and 0.1 times on hits. Setting that against the uncached baseline, the 5-minute tier breaks even at a hit rate of roughly 22%; below that, the write premiums cost more than the reads save. Anthropic's one-hour tier, at 2x writes, needs roughly 53% just to break even under the same pattern. Independent engineering analyses generally treat a sub-60% hit rate on an otherwise stable prompt as a structural design smell rather than noise — the kind of signal that says your prefix is not as stable as you think it is.

Concrete anchor rates help here. Claude Fable 5 prices cache reads at $1 per million tokens against a $10 base input rate — the same 90% shape — and pairs it with a Batch API at $5 input / $25 output. We broke down how those two levers stack in Fable 5's usage-credit and cache-batch economics. The June primer's central case study still holds as supporting evidence, too: ProjectDiscovery reportedly lifted its hit rate from 7% to 84% by moving volatile working memory out of the system prompt, cutting overall LLM cost 59% — a reminder that hit rate is an architecture output, not a billing setting.

The ordering rule from the primer — most-stable content first — gets its teeth from the invalidation hierarchy. On Claude, the cache is structured as tools, then system, then messages, and a change at any level invalidates everything after it. Anthropic's recommended ordering is tool definitions, system prompt, reference documents and context, conversation history, and the live volatile query last; content placed after the final breakpoint can change freely without invalidating anything before it.

The cascade is more granular than most teams assume:

• Changing tool definitions invalidates the tools, system, and messages caches entirely — the most expensive possible miss.
• Changing tool_choice invalidates the tools and system levels.
• Toggling web search or citations invalidates only the tools-level cache.
• Adding or removing images, or changing extended-thinking settings, invalidates tools and system but leaves messages intact.

Two recent platform changes reward prefix discipline. Since February 5, 2026, Anthropic isolates prompt caches per workspace within an organization across the Claude API, AWS Bedrock, and Microsoft Foundry — so two teams sharing an org no longer share (or pollute) each other's cache. And the Messages API now accepts system entries inside the messages array, letting a harness update instructions, permissions, or token budgets mid-task without breaking the cached prefix or routing the update through a fake user turn.

Here is the constraint that separates chat apps from agents. On Claude, you get a maximum of four explicit cache_control breakpoints per request (an automatic top-level breakpoint consumes one of the four), and the system checks up to 20 blocks backward from each breakpoint for a matching prior cache write. A chat app adds one or two blocks per turn and never notices the window. A tool-heavy agent turn — one assistant message fanning out into a dozen tool calls, each returning a result block — can add more than 20 blocks in a single turn. When that happens, the next request's breakpoint looks back 20 positions, finds no match, and silently re-writes the entire prefix at premium rates. No error, no warning; just a bill that quietly grew 10x on the input side.

Anthropic's own guidance is the fix: in long turns, place an intermediate breakpoint roughly every 15 blocks so the lookback window always finds an anchor. Practically, that means your harness needs breakpoint placement logic that counts blocks, not just a static annotation on the system prompt — a genuinely architectural requirement that no amount of prompt-ordering discipline substitutes for. GPT-5.6's budget is looser on the read side — up to four new writes per request with reads looking back across up to 50 prior breakpoints — which materially reduces the silent-miss risk for very long sessions, and is worth weighing when you choose a model family for marathon agent loops.

Two further tools round out the budget. Anthropic supports cache pre-warming: a request with max_tokens: 0 and a cached system block loads the prefix into cache before the first real user request, improving time-to-first-token for latency-sensitive agents (the write still costs 1.25x if the prefix is not already cached). And this problem now has an academic literature: a recent pre-print, "Don't Break the Cache: An Evaluation of Prompt Caching for Long-Horizon Agentic Tasks," studies cache-breaking behavior specifically in multi-step agent loops — evidence that cache design for long-horizon agents has become an active research problem rather than a cost-optimization footnote.

Prompt caches do not travel between models. A KV cache is a model-specific artifact, and some vendors' agent harnesses now document explicitly that switching models mid-session invalidates the prompt cache. For a single assistant that is a nuance; for a multi-stage pipeline it is a tax schedule. The popular cost-optimization pattern — a cheap model for retrieval and triage, an expensive one for synthesis — forces a full cache write at every stage boundary. Each swap turns what would have been a 90%-off read of the accumulated context into a 125%-of-base write of that same context.

The worked example below puts numbers on it. Assumptions, stated plainly: an agent session with a 20,000-token stable prefix (tool definitions, system prompt, reference docs), 2,000 tokens of new conversation appended per turn, priced at Fable 5's published rates — $10 per million input tokens base, $12.50 cache write, $1 cache read — with each turn writing its new increment and reading everything prior. This is an original calculation from those inputs, not a vendor benchmark.

Read the middle rows carefully. A single mid-session swap is survivable: the swap turn itself costs roughly 9.5x what the cached turn would have ($0.90 versus about $0.10 at turn 26, because the full 72,000 accumulated tokens re-write at premium), adding around 16% to the whole run — and every turn after the swap reads from the new model's cache normally. The bottom row is the trap. A pipeline that alternates model families on every call never earns a read at all: it pays the 1.25x write premium on the full context every time and lands 25% above the no-cache baseline. Caching badly is worse than not caching.

The design principle that falls out is what we call model-homogeneous staging: draw pipeline stage boundaries so that every step sharing an accumulated context runs on one model family, and route between pipelines rather than inside a session. Cheap-model triage still makes sense — as a separate stage with its own short prefix, not as an interleaved participant in a long shared context. A second pre-print from this summer, "The Harness Effect: How Orchestration Design Sets the Token Economics of Enterprise Agentic AI," argues the general form of the point: orchestration design, not model choice alone, is a primary driver of token economics. Our model-routing strategy guide covers how to pick the right family per stage; the addition here is that the routing boundary is now also a cache boundary, and it should be priced as one.

Cache-first design is four decisions made before the first prompt is written: what goes in the stable prefix (and whether it clears the model's minimum cacheable length), where breakpoints sit and how the harness maintains them through long turns, which TTL tier matches the traffic pattern, and where model boundaries fall. The matrix below maps common workload shapes to the pattern that fits.

Then instrument it. DeepSeek's API returns prompt_cache_hit_tokens and prompt_cache_miss_tokens on every response; Anthropic and OpenAI report cache usage in their responses as well. Wire hit rate into the same dashboard as spend, alert when a stable workload drops below your derived breakeven floor, and treat a sustained drop as a deploy regression — because it usually is one: someone reordered the prompt, changed a tool definition, or added a timestamp to the system prompt. Note that this whole post operates at the application layer; the serving-infrastructure layer underneath has its own levers, which we covered in KV cache optimization techniques. If you want a second set of eyes on an agent architecture before the invoices scale with it, our AI transformation engagements start with exactly this kind of cost-architecture review.

Looking forward, the direction of travel seems clear enough to plan around. Two of the three major vendors now charge for cache writes, two of three expose explicit breakpoints, and the academic literature has started treating cache behavior as an agent-design variable. We expect the remaining free-write, implicit-only configurations to keep converging toward the explicit, write-premium model — which means architectures designed around breakpoint budgets and model-homogeneous stages today are aligned with where the pricing is heading, not just where it stands this month.