The discounted read is only half the bill. If your AI workflow pays to create a cache that nobody reuses, the optimisation can increase costs.

A cache discount can start with a more expensive request

Your AI supplier can make reused input cheaper while making the first request more expensive. Both statements can be true. For a UK business running document analysis, customer support or internal knowledge tools, the useful purchasing question is no longer simply whether caching is enabled. It is whether each paid cache write earns enough subsequent reuse before the relevant content changes or expires.

There is a timely reason to revisit that question. Microsoft’s prompt caching documentation, updated on 6 November 2026, says charges for supported 12-hour prompt cache writes apply to usage from 1 November 2026. It distinguishes newer GPT-5.6 and later deployments from earlier models, which do not have the same extra cache-write charge. This is a model and deployment-specific change, not a claim that every Azure AI request suddenly became more expensive.

Prompt caching reuses computations for a repeated opening part of an input. It does not mean the system returns yesterday’s finished answer. A large reference manual followed by changing customer questions is a plausible candidate. A different long document supplied for every isolated question may be a poor one. The shared instructions might still be reusable, but that does not make the changing document itself a valuable cache investment.

Ask whoever manages the integration to separate ordinary input, cache creation, cache reads and generated output in the cost report. Then ask which of those lines the current contract actually bills separately. Avoid adding an ordinary input charge twice when a supplier’s write rate already includes that processing. Build the calculation from the invoice rules rather than a generic online calculator.

The leadership decision is straightforward: treat paid cache creation as a small upfront investment. It needs an expected payback period, an owner and evidence of reuse. A dashboard showing discounted reads alone cannot demonstrate that the investment paid back. That is particularly important when upgrading a model changes the billing rules without changing the business task.

A cheaper cache read does not prove that the cache write paid for itself.

Calculate the reuse threshold before extending retention

Use a deliberately simple calculation before considering a longer cache lifetime. Let ordinary processing of one fixed prefix cost B, creation of its cache cost W, and one later cached read cost R. For N requests using that same prefix, the uncached comparison is N multiplied by B. The cached comparison is W plus N minus one cached reads. This model excludes output, changing input, storage and other charges, which must be added where relevant.

Caching wins on that prefix when the later read savings exceed the extra initial cost: N minus one, multiplied by B minus R, must be greater than W minus B. If a provider quotes an additional write surcharge instead of an inclusive write rate, substitute the correctly assembled total for W. Do not mix those two conventions. The equation is a decision aid, not a universal description of every provider’s invoice.

Consider an illustrative UK budget, not a vendor quotation. Suppose ordinary processing of the reusable content costs £1 per request, creating the cache costs £2, and a later read costs £0.10. Two uncached requests cost £2; one write and one read cost £2.10. Three uncached requests cost £3; one write and two reads cost £2.20. The third request is the first point where this simplified example saves money.

The lifetime matters because those later requests must actually reuse the entry. Anthropic’s prompt caching documentation gives a concrete supplier example: five-minute cache writes use a 1.25 times base-input multiplier, while one-hour writes use twice base input. Read multipliers vary by model. Those are relative rates, not sterling prices, and they should not be transplanted to Azure or another platform.

In practice, compare the shorter lifetime with the longer one, not just caching with no caching. Paying more upfront is sensible only if the longer window captures enough additional reads or delivers a justified latency benefit. A quiet overnight workflow and a busy daytime assistant can therefore deserve different policies even when both use the same model and reference material.

In the illustrative £1/£2/£0.10 example, the third request is the first saving.

Test normal traffic, not a demonstration full of repeats

A cache demonstration is easy to make impressive: send the same long prompt repeatedly within a minute and show the cheaper reads. That proves the mechanism can work. It does not establish the return for your actual operation, where customers ask unrelated questions, documents change, staff pause for lunch and integrations restart. The acceptance test should preserve those ordinary gaps and variations.

Choose one workflow and capture a representative pattern of request times and reference versions. Prefer synthetic content or appropriately protected test data. Compare the existing configuration with the proposed cache policy using the same task mix, quality checks and completion criteria. Do not manufacture extra calls to improve the hit rate. A request created solely to keep a cache warm belongs on the cost side of the experiment.

For a service business answering questions about a stable maintenance handbook, a useful trial includes a morning burst, an hour with no enquiries, an afternoon burst and a handbook revision. Mark which reference version each request should use. For a firm reviewing a different tender pack once a day, test that pattern instead. Its long inputs are not evidence that a long-lived cache will be profitable.

Record requests, cache-write tokens or billed creation units, cached reads, uncached input, output and total cost. Add the number of successfully completed business tasks so the result can be reported as pounds per accepted task. Track response time as a separate outcome. A small additional cost may be worthwhile for a customer-facing service that becomes materially faster, but that is a service decision rather than a token-saving claim.

Retain the cold-start and expiry results rather than averaging them away. Check the first request after a deployment or policy change as well. Repeat the comparison when model, contract, traffic pattern or retention setting changes. You do not need a permanent custom measurement platform for a modest pilot: provider usage exports and a reviewed spreadsheet can be enough. The important requirement is a fair comparison, not a sophisticated dashboard.

A request made only to keep a cache warm is a cost, not evidence of demand.

Make reuse safe before making it cheaper

The cheapest reusable context is often the material that can safely be shared across many tasks: approved public product descriptions, stable operating instructions or a current reference manual. Personal customer histories and confidential client files need tighter boundaries. Do not widen those boundaries merely because a shared cache would produce better numbers. A saving that depends on exposing the wrong information is not a saving to approve.

Google Cloud’s context caching guidance distinguishes automatic implicit caching from explicitly created caches, and notes that explicit caching can carry storage costs based on duration. Its security guidance also tells organisations to align cache boundaries with end-user permissions in agentic workloads. The practical lesson is broader than any one supplier: project-level isolation does not by itself describe which employees or customers your application should be allowed to serve from a particular context.

Keep the stable reference separate from changing customer material in the request design where the supported API permits it. Give reference versions meaningful identifiers and test what happens when prices, service terms or permissions change. Do not keep an obsolete handbook in use to preserve a favourable hit rate. The authoritative reference must win over the financial incentive to reuse an old prefix.

For UK organisations, ICO guidance on storage limitation explains that personal data retention must be justified by purpose and should not last longer than necessary. The page is under review following the Data (Use and Access) Act, so treat it as current guidance to check alongside applicable obligations, not as a cache-specific legal approval. A provider’s technical lifetime is not your organisation’s complete retention policy.

What this means in practice is a joint check by the workflow owner and whoever handles data protection or security. Record what enters the cache, the contractual retention behaviour, access boundaries and available deletion controls. Distinguish a minimum reuse lifetime from a guaranteed deletion deadline; they are not interchangeable promises. Where the provider does not offer the control a sensitive workload requires, reduce the cached content, choose another supported configuration or do not cache that material. The financial model comes after that boundary is understood.

Never preserve obsolete or over-shared context just to improve a cache hit rate.

Buy the business outcome, not the highest hit rate

The strongest counterargument is reasonable: for a busy assistant with a large stable reference, caching can be an obvious improvement. In that situation, elaborate analysis can cost more staff time than the optimisation saves. The answer is proportionality. Establish the billing model, confirm reuse with real traffic and set a lightweight review trigger. Do not turn a small configuration choice into a six-month programme.

Equally, avoid demanding that every cache entry makes a profit in isolation when the service goal includes predictable response times. A rarely reused entry might still be acceptable if it supports a clearly valued customer experience. Put that justification in the decision record. Then measure the service benefit honestly instead of presenting it as a proven reduction in expenditure.

For procurement, ask three separate questions. What is the applicable write, read and storage pricing for this model and deployment? How much reuse does our traffic deliver within each supported lifetime? What operational benefit remains after quality checks, failures and reference updates? These questions make competing supplier offers easier to compare without assuming that their definitions of cache tokens are identical.

Give the integration owner a small release checklist: preserve reference versions, retain the relevant usage fields, compare a cold request with a repeated one and check the cost after an expiry. Ask finance to reconcile the experiment with the actual bill. If the platform aggregates usage differently from the application, resolve that discrepancy before forecasting annual savings.

Our earlier guide on measuring prompt caching savings explains why a headline discount is not the whole outcome. The narrower decision here is whether paying to create a reusable prefix earns its return under the current contract. Start with one representative workflow, choose the shortest lifetime that meets the need and review the result after a normal trading period. Keep it when the overall outcome improves. Change it when demand or supplier billing changes. A high hit rate is useful evidence, but it is never the business objective on its own.

The right cache policy is the one that improves accepted work, not the one with the prettiest hit rate.

Key Takeaways

  • Ask for the actual model and deployment-specific cache-write, read and storage charges before forecasting savings.
  • Calculate the minimum reuse needed to recover any extra creation cost, without double-counting ordinary input.
  • Test realistic request gaps, expiry and reference changes rather than a burst of identical demonstration calls.
  • Report pounds per accepted business task alongside response time, not cache hit rate alone.
  • Keep customer permissions and justified retention boundaries intact even when broader sharing would increase reuse.