Caching on GPT-5.6 Luna API is a modest optimization on top of a model that is already cheap — and that is exactly why it is worth doing. Luna’s cache reads cost about $0.02 per million tokens, against a fresh-input price of $0.20. This Luna/Terra/Sol cost guide covers the same lever across the family.
When a model is already the cheapest tier, teams often skip caching because the base is low. That is a mistake on high-volume workloads, because a tenfold reduction on the input side is the same tenfold whether the base is $5 or $0.20. On the volume that Luna is built for, $0.02 reads turn the input cost from negligible to almost nothing.
How the lever works
The mechanism is the same as on any model: send a request with a large stable prefix, and the provider stores it as a cache. Subsequent requests that reuse that prefix are charged the cache-read rate instead of the fresh-input rate. For Luna, the fresh price is $0.20 per million and the cache-read price is $0.02 — a tenfold drop on the input side. The write cost is similarly small, paid once when the prefix first appears. The economics reward workloads with a repeated prefix: a system prompt, a document, an agent’s accumulated context.
Where the repeated prefix lives
The cacheable content is the content your requests share. In a chat product, it is the system prompt and the instruction block every request carries. In a document pipeline, it is the document itself, sent with each question. In an agent, it is the accumulated context each step reuses. The design rule is the same as everywhere: put the stable content at the front of the prompt, and keep the changing part at the end. A prompt with the stable content in the middle breaks the cache and silently pays the fresh price for what could have been a two-cent read.
The arithmetic at Luna’s scale
Run the numbers on a high-volume workload. A chat product sends a 10K-token system prompt with every request, and serves a million requests a month — ten billion system-prompt tokens, all repeated. Uncached, that is $2,000 a month in input cost at Luna’s fresh price. Cached, it is $200. On a flagship the same pattern would be $50,000 uncached and $5,000 cached. The tenfold is the same; the absolute saving scales with the base, and the base is exactly the volume workload Luna targets.
The tenfold on the cheapest tier
The point that is easy to miss is that caching matters most where volume is highest, and volume is highest on the cheap tier. The workloads routed to Luna are the high-volume ones, and high volume is where a tenfold reduction compounds. Teams that skip caching on the cheap model leave the largest absolute saving on the table, because the cheapest tier carries the most traffic.
Caching and the tier boundary
One interaction to know: Luna’s two price tiers are divided by context length, and long-context requests pay a higher rate. Caching applies within that structure, so a cached long-context read still saves the same factor. The design guidance is unchanged — lead with stable content, reuse the prefix, and watch the cache-read share of your input tokens as the signal that the lever is working. If the share is low, the prompt structure is the reason, and reordering is the fix.
Caching in the context of the whole stack
Caching on Luna is one lever among several, and it is worth seeing how it fits with the others. The family’s cost story is tiering: route the easy majority to Luna, escalate the hard tail to a stronger model. Caching operates inside that story, cutting the input cost of the tier that carries the volume. The two levers are complementary — tiering selects which model, caching cuts the per-call cost of the model that runs most. A workload that is both tiered and cached gets the double benefit: most calls on the cheap tier, and the cheap tier’s input side cut tenfold. For a high-volume workload, that combination is the difference between an AI cost that matters and one that is a rounding error. The caching lever is small in principle and large in effect, precisely because it applies to the tier that runs on everything.
The habit that makes caching work is structural: every request leads with the content that repeats, and the variable part follows. Once that structure is in place, the tenfold applies automatically to everything that fits the pattern.
The takeaway
Caching on GPT-5.6 Luna cuts the input price from $0.20 per million to $0.02 per million on reads — a tenfold reduction on a model that is already the cheapest tier. On the high-volume workloads Luna is built for, that is the largest absolute saving available, because the cheap tier carries the most traffic. Lead with the stable prefix, reuse it, and track the cache-read share; on Luna, caching turns negligible input cost into almost none.
