OpenAI's GPT-6 Caching Toolkit: The Real API Bill Math

Search interest in “openai api pricing” is up 153 percent in three months. That number tracks a real shift: the people paying these bills have stopped shopping on benchmark scores and started shopping on the cost of a finished task. On September 22, 2026, alongside the GPT-6 Sol and Luna launch, OpenAI shipped the piece that actually moves that number for anyone running an agent: a rebuilt prompt caching system for the whole GPT-6 family, with a usage dashboard, a cache-miss diagnostics tool, explicit cache breakpoints, prewarming, and the ability to change reasoning effort mid-conversation without destroying the cache.

Read the announcement and you get a feature list. Read the pricing docs and you get something more useful: the arithmetic that decides whether caching saves you 46 percent on an agent run or quietly costs you 35 percent more. That arithmetic is the part nobody puts in a launch post.

What OpenAI actually changed on September 22

Prompt caching is not new. OpenAI has discounted recently seen input tokens for a while, and the older system worked implicitly: you sent your prompt, OpenAI guessed where the reusable prefix ended, and you got a discount when it guessed right. Unguessable prefixes meant silent misses you could not see.

The GPT-6 generation changes four things:

• Automatic higher hit rates. OpenAI now applies cache discounts to eligible shared prefixes reused within a 30-minute window. Caching is on by default for supported models, so the default path improved without a code change.
• A Prompt Caching Dashboard. A usage view that shows what share of your input tokens are served from cache over time, with an input composition chart splitting cached from uncached tokens. This is the first time cache hit rate is a first-class metric in the usage UI rather than something you inferred from a bill.
• A cache-miss diagnostics tool. When a request misses, the API can return a structured explanation that names the reason and sizes the damage:

{
  "prompt_cache_diagnostics": {
    "type": "cache_miss",
    "reason": "tools_changed",
    "comparison_reusable_tokens": 5629,
    "cache_missed_tokens": 5629
  }
}

That reason field is the whole point. It tells you whether your miss came from a changed tool definition, a changed model setting, or changed input, instead of leaving you to bisect your own request builder.

• Explicit control. prompt_cache_options lets you set the cache mode (implicit or explicit-only), the time to live (the only supported value, 30m, is also the default), and prewarming for known context. Explicit breakpoints let you pick where the reusable prefix ends instead of hoping the engine guesses it the way you would have.

The cache math that decides your bill

Here is the part that matters, straight from OpenAI’s pricing documentation. For GPT-5.6 and later models, including the GPT-6 family:

• A cache write costs 1.25x the standard uncached input rate.
• A cache read costs 0.1x that rate.

So a single prefix that you write once and fully reuse once costs 1.35x its ordinary input cost, against 2x for processing it twice with no caching. Write once and read it back nine more times and you pay 2.15x instead of 10x. That is the 90 percent discount doing its job.

The trap is the mirror image. If a prefix is written and never reused, you paid 1.25x for nothing, and the cache write is strictly worse than no caching at all. A 25 percent surcharge on a prefix you only use once is a 25 percent tax on careless prompt assembly.

This is why the old “caching is free money” advice is wrong at scale. Whether caching helps you is a function of one number: your cache hit rate, weighted by how big your cached prefix is relative to your total input. Get the hit rate above roughly the break-even point and you save. Below it and the 1.25x write premium eats the discount.

Let me put numbers on it. Say your agent sends 12,000 input tokens of shared context plus 3,000 tokens of fresh turn-by-turn input, per turn, over a ten-turn run:

• No caching: all 15,000 tokens billed at the full input rate every turn. That is 150,000 input tokens.
• Caching with a clean hit rate: 12,000 write tokens once (at 1.25x), then 12,000 cached reads on the next nine turns (at 0.1x), plus 3,000 uncached tokens every turn. In rate units, that is roughly 15,000 for the write turn, then 4,200 per turn for the nine reusing turns: about 52,800 rate units, or 65 percent less input cost than the uncached run.
• Caching with a broken hit rate: if a changed tool definition invalidates the prefix every other turn, you pay the 1.25x write repeatedly and only some reads land. That is how a caching setup ends up more expensive than no caching at all.

Same feature, three outcomes, decided entirely by hit rate. The dashboard and the diagnostics tool exist precisely because OpenAI knows most teams have no idea which of those three they are in.

Why agent runs are the ones that win or lose

A single chat completion has almost nothing to cache: the system prompt is small and the conversation is short. An agent run is the opposite. It carries forward the same instructions, the same tool definitions, and the same reference material across dozens or hundreds of requests. That shared prefix is exactly what caching wants to keep.

This is where the new controls map onto specific failure modes heavy users hit:

Change reasoning effort without breaking the cache. On GPT-6 models you can now raise or lower reasoning effort between responses by appending a configuration_update, leaving the request-level reasoning effort unchanged. Before, dialing effort up for a hard step forced a settings change that invalidated the prefix. Now you can spend more reasoning on the hard turn and less on the routine follow-up while the agent’s reusable context survives intact.

Keep tools append-only. The most common real-world miss reason is tools_changed. If you add or remove a tool definition, everything after that point in the prefix can no longer match. The fix is to keep tool definitions, schemas, and ordering stable, use allowed_tools to make only the relevant tools callable, or set tool_choice to none when no tools are needed, rather than deleting the definitions. New instructions should be appended as developer messages near the end of context, not spliced into the middle of a stable prefix.

Prewarm what you know. For GPT-5.6 and later, setting prompt_cache_options.prewarm to true prepares known context ahead of time. If your app has shared instructions, tool definitions, or reference material that every session starts from, you can warm the cache during startup, before the user asks their first question, and move that processing out of their wait.

None of this is exotic. It is the difference between an agent that gets cheaper per turn as it runs and one that quietly pays a write premium on every step.

Caching is now a cost-control surface, not a checkbox

The strategic read for anyone paying 300 dollars a month or more across providers is that caching has crossed from an optimization trick into a line item you manage.

The first version of this shift landed on Anthropic’s side in September, when Claude Fable 5.1 cut the cached-token read price from 1.00 dollar to 0.25 dollar per million tokens, a 75 percent reduction on the cache-read line that Anthropic said translates to roughly 25 percent cheaper standard workloads and up to 45 percent cheaper for cache-heavy automated tasks. OpenAI has now answered on its own side with default-on higher hit rates, a 90 percent read discount, and the instrumentation to prove it.

Put the two together and a pattern is hard to miss. Both labs have concluded that the way to keep heavy users is to make their repetitive agent workloads cheap, and the way to lose them is to let a silent cache miss turn a predictable bill into a surprise. Every lever being shipped, dashboards, diagnostics, breakpoints, prewarming, mid-run effort changes, exists to give you control over one metric: the share of your input that is served from cache rather than computed.

If you cannot see that share, you are not managing your AI cost. You are guessing at it.

What to do this week

1. Open the Prompt Caching Dashboard and read your cache hit rate. Not your total spend. Your hit rate. Everything downstream follows from that number. If it is low and your workload is an agent loop, you have found money.
2. Run the diagnostics tool on one unexpected miss. Look at the reason field. If it reads tools_changed, your tool definitions are unstable; fix the append-only discipline before touching anything else.
3. Split your prefixes deliberately. Put stable content (instructions, tool schemas, reference material) before an explicit breakpoint, and volatile content after it. Let explicit-only mode protect you from paying 1.25x in cache writes on suffixes that never get reused.
4. Audit sub-30-minute reuse. The default 30-minute TTL refreshes on every write or reuse, so a steady agent run stays warm. But a batch job that fires once an hour starts from cold every time and pays the write premium without ever collecting the read discount. Check the cadence against the window before you assume caching helps a given job.
5. Re-baseline cost per completed task, not cost per token. A 65 percent input-cost cut on a run that fails half the time is not a 65 percent saving on outcomes. Log completed tasks, not just tokens, so the caching win shows up where it actually counts.

Prompt caching in 2026 is not a feature you enable and forget. It is a lever with a break-even point, and the GPT-6 toolkit finally gives you the instrument panel to see which side of it you are on. The teams that treat cache hit rate as a first-class cost metric will run the same agents as everyone else for meaningfully less. The teams that do not will keep reading their bill and wondering where the money went.