GPT-6 Prompt Caching: Breakpoints, Tools and Cost

GPT-6 prompt caching now gives API developers more control over which shared prompt prefixes are reused, plus a dashboard, cache-miss diagnostics and prewarming. OpenAI says the GPT-6 family improves cache hit rates by default and applies cache discounts when eligible shared prefixes are reused within a 30-minute window. The practical change is not that every repeated request becomes cheap automatically: teams can now see, test and deliberately shape the prefix that survives across long-running agent turns. Read OpenAI’s announcement.

GPT-6 prompt caching: what changed

Prompt caching reuses the model state created for an unchanged beginning of a request. That beginning can include developer instructions, tool definitions, reference material and earlier conversation turns. The model still processes new content and generates a fresh response; caching does not replay an old answer.

OpenAI’s September 22 update packages several improvements around that mechanism. GPT-6 applications get higher cache hit rates by default, eligible reuse within a 30-minute window, explicit cache breakpoints, a Prompt Caching Dashboard, per-request diagnostics and an option to prewarm known context. GPT-6 can also change reasoning effort during a conversation with a configuration_update while preserving the earlier prefix, provided the request-level reasoning setting is not rewritten.

This matters most for persistent agents because their requests often carry the same large foundation: policies, repository context, tools and accumulated history. Our GPT-6 API overview explains the wider API surface; this dated update focuses only on the new caching controls and how to evaluate them.

Explicit cache breakpoints versus implicit mode

GPT-6 supports both implicit and explicit cache behavior. In implicit mode, OpenAI selects eligible message boundaries, including the latest eligible message, while also considering earlier boundaries. This is the lower-maintenance choice for applications that append turns without repeatedly rewriting their beginning.

Explicit mode is useful when the application knows where stable context ends. A developer can place a prompt_cache_breakpoint after a reusable content block and set prompt_cache_options.mode to explicit. Content after the last selected breakpoint is processed normally, so rapidly changing user data does not have to become a new cache write.

A support agent offers a useful example. Put the stable support policy, product reference and unchanged tool schemas before an explicit breakpoint. Put the current customer message, a live account status and the present timestamp after it. That layout preserves a reusable base without pretending that dynamic account data is stable. It is an untested editorial implementation example, not a guarantee of a cache hit.

The prefix still must qualify. OpenAI documents a minimum of 1,024 visible input tokens for GPT-5.6 and later models, including GPT-6. Expanding a short prefix merely to cross that threshold can waste money, so measure the complete workload rather than optimizing only a hit-rate percentage.

GPT-6 prompt cache diagnostics and monitoring

The new Prompt Caching Dashboard shows the share of application input served from cache and separates cached from uncached input over time. That turns caching from an assumption into an operational metric. A deployment should watch at least cache-read share, cache writes, uncached input, latency and total request cost.

For an individual miss, the diagnostics feature compares a current Responses API request with a recent completed response. Supply the earlier response ID through prompt_cache_options.comparison_response_id, then inspect prompt_cache_diagnostics and usage.input_tokens_details.cached_tokens. OpenAI’s example reports a tools_changed reason, the number of reusable comparison tokens and the estimated tokens that missed. The comparison asks for an explanation; it does not load the earlier conversation or alter caching behavior.

Start with structural causes before changing model prompts. Check whether the model or service tier changed, whether a tool name, schema or ordering moved, whether output-format settings changed, or whether content was inserted near the beginning of the request. OpenAI recommends keeping tool definitions stable and limiting which tools are callable with allowed_tools or tool_choice, rather than deleting and rebuilding the tool list every turn. New overriding instructions can be appended later in context so the stable prefix remains intact.

Teams reviewing broader model costs can use our GPT-6 pricing guide, but this News article does not modify its verified rate tables.

Prewarming and the 30-minute cache window

Prewarming lets an application prepare known context before the interactive request arrives. Set prompt_cache_options.prewarm to true on a Responses API request containing the shared prefix, wait for it to complete, then send the real request with the same prefix and prewarming disabled or omitted. OpenAI notes that prewarmed tokens are billed at the cache-write rate. The benefit is latency placement: work happens during startup or another planned moment rather than after the user asks a question.

For GPT-5.6 and later, prompt_cache_options.ttl has one supported value, 30m, which is also the default. The documentation defines that as a minimum period after the latest write or reuse; OpenAI may retain an entry longer. Reusing a prefix refreshes its lifetime without another write charge. Applications should not describe the setting as a guaranteed 24-hour GPT-6 cache or build correctness around an entry remaining available.

The cost model also changes how a rollout should be judged. OpenAI lists a cache read at 0.1 times the uncached input rate and a write at 1.25 times that rate for GPT-5.6 and later. A write followed by one full read costs less than processing the same prefix twice, but a prefix that is written and never reused can cost more than ordinary uncached input. Cached tokens also continue to count toward token-per-minute rate limits.

A safe rollout checklist for persistent agents

Begin with one repeatable agent workflow instead of enabling explicit control everywhere. Capture a baseline for input tokens, cache reads, cache writes, time to first token, total cost and task quality. Keep the model, service tier and evaluation cases fixed while testing.

Next, move stable instructions and reference material to the front, keep tool schemas and ordering stable, and put changing customer or request data after the intended breakpoint. Test implicit mode first if the conversation naturally grows by appending turns. Use explicit breakpoints where the application can identify a durable boundary, and prewarm only context that is likely to be reused soon.

After deployment, compare request pairs with diagnostics whenever the dashboard shows a sudden hit-rate drop. Do not treat a high hit rate as the only success metric: fewer useful tokens, a smaller context or compaction can still lower total cost even if the percentage of cached input falls. The GPT-6 prompts guide can help separate prompt structure from the mechanics of caching, while the GPT-6 Sol and Luna launch page provides the current family context.

Finally, keep the limits visible. Exact prefix compatibility matters, cache entries expire, manual cache clearing is not available, and a cached prefix does not make outputs deterministic. The new tools make GPT-6 prompt caching observable and tunable; they do not remove the need for workload-specific tests, cost alerts and output evaluation.