How Cache Influences Your Budget

You've learned that cached tokens are cheap and uncached tokens are expensive. Now let's build the exact formula for how much a multi-turn agent session costs — and see the numbers with real DeepSeek pricing.

The Three Prices

Every token you send or receive is billed at one of three rates. Providers publish all three, and they are far apart:

Symbol	Applies to	Why it's priced that way
Pcr	Input tokens that hit the cache	The GPU work was already done on an earlier request
Pi	Input tokens the model sees for the first time	Full attention pass required
Po	Every token the model generates	One forward pass per token, generated one at a time

Here are DeepSeek's actual numbers, in ¥ per million tokens:

Model	Time slot	Pcr	Pi	Po
deepseek-v4-flash	Off-peak	0.05	1.50	4.50
deepseek-v4-flash	Peak	0.10	3.00	9.00
deepseek-v4-pro	Off-peak	0.15	4.50	13.50
deepseek-v4-pro	Peak	0.30	9.00	27.00

Two ratios are worth memorising: fresh input costs 30× a cache read, and output costs 90×. Every design decision you make about agent architecture is really a decision about which bucket your tokens land in.

Now let's build the bill one piece at a time.

Part 1: Cache Reads

The system prompt gets re-read every single turn. It sits at the front of the prefix, it never changes, and it is charged at the cache rate on all $n$ turns:

Everything the conversation produces later gets re-read too, but not $n$ times each. Turn 1's block is re-read by turns 2 through $n$. Turn 2's block by turns 3 through $n$. The last turn's block is never re-read at all.

That decay is exactly $(n - i)$:

This is usually the largest token count in the whole session and one of the smallest line items on the invoice. That's the cache doing its job.

Part 2: Fresh Input

Only truly new tokens cost full price. There are two kinds. First, the cold-start read of $S_0 + U_0$ — somebody has to pay for the very first pass. Second, per turn, the tokens that arrive from outside the model: your user's message $U_i$ and the tool result $TR_i$.

Note what is not here: $R_i$, $C_i$ and $T_i$. The model generated those, so they entered the cache as a side effect of being generated. You never pay input price for them.

Part 3: Output

The model's generation always costs the same, at the highest of the three rates. Reasoning, answer, and tool call arguments are all output:

Nothing can be cached here — output is produced one token at a time, every time. This term is the one you control with prompt design and reasoning_effort, not with caching.

Putting It Together

Stack the three parts and you have the whole bill for an $n$-turn agent session:

For Direct Chat, set $R$, $T$ and $TR$ to zero — those token types don't exist in a plain chat.

This is a model, not an invoice. It counts the cold-start read of $S_0 + U_0$ in both of the first two terms, which overstates a 10-turn session by well under one percent. Cache eviction and block alignment also move real numbers slightly.

Try the Numbers

The calculator below evaluates the formula live. Pick a model and a time slot, size your turns, and watch the three terms move against each other.

A Worked Example

Let's say you run a 10-turn coding agent session with deepseek-v4-flash in the off-peak window. Those are the calculator's default settings:

• System prompt plus opening request: $S_0 + U_0$ = 1,350 tokens
• Each turn produces 2,500 reasoning + 450 answer + 40 tool call + 200 tool result + 150 user = 3,340 tokens
• Prices: P_cr = 0.05, P_i = 1.50, P_o = 4.50 ¥/M

Term by term:

The 45 in term ① is $\sum_{i=1}^{10}(10-i)$ = 9 + 8 + … + 1 + 0. It's the reason 163,800 tokens flow through the cache in a session that only ever sent 168,650 input tokens: 97% of your input is a re-read.

Now the same session with caching switched off. Every request pays full input price for its entire history:

That's a 61% saving on the session. Look only at the input side and it's starker: 0.0155 ¥ with cache versus 0.2510 ¥ without, about 16× cheaper.

But notice what the saving reveals. Once caching is doing its job, output is 0.1346 of a 0.150 ¥ bill — 90% of what you pay. Your input problem is solved; your output problem is now the whole problem.

What This Means for Design

1. Keep the prefix frozen. A stable system prompt is worth more than a clever one that gets tweaked per request. Put anything volatile — timestamps, session IDs — at the end of the message list, never the front.
2. Prefer long sessions to fresh ones. Cold starts are the expensive part. Ten turns in one session cost far less than ten one-turn sessions.
3. Compress reluctantly. Summarizing history to save context window trades a cheap cache read for an expensive cold start. Sometimes worth it, rarely free.
4. Spend your effort on output. With cache on, output dominates. That makes reasoning_effort, answer length, and how many turns a task takes your real cost levers.

That last point is where the rest of these tutorials go. If the cheapest agent is the one that reaches the answer in fewer, better-informed turns, then the interesting question becomes: how do you make an agent that already knows what to do? That's what a Skill is for.