Cache read tokens are the quiet majority of an agent session
Cheap repetition, not fresh work. The count climbs while the cost per turn stays low.
·2 min read
Cache read tokens are the quiet majority of most agent sessions, and mistaking them for fresh work is the usual reason a token total looks alarming. A read is a reuse of text the provider has already processed, priced at a fraction of new input. The UsageAtlas guide documents the distinction.
What a cache read represents
When a conversation continues, the earlier turns are sent again. With prompt caching enabled, that repeated prefix is stored once and then read back on each later request.
So a session with a hundred turns does not pay full price a hundred times for the same context. It pays to write the prefix, then pays the cheaper read rate as the conversation grows.
The shape of a typical session
| Phase | Dominant token type | Cost character |
|---|---|---|
| First turn | Input and cache write | Highest per-turn cost |
| Middle turns | Cache reads plus new input | Cheap, with a small tail |
| Final turns | Output, if the model is writing a lot | Rises with generated volume |
The middle phase is why totals reach millions. The count climbs with every turn, while the cost per turn stays low.
Why the read rate matters commercially
If reads were priced like input, long agent sessions would be prohibitively expensive. The discount is what makes a conversational workflow viable, and it explains why providers invest in caching at all.
For a user, the practical consequence is that thread length is not the villain people assume. Thread length combined with constant new work is.
Where the money actually goes
- Output, per token, is the most expensive element.
- Cache writes carry a small premium over input on some providers.
- Fresh input is avoided by pointing at files rather than folders.
- Reads are cheap and mostly unavoidable in a long conversation.
That ordering is the one to remember when choosing what to optimise.
A practical example
Picture a session that opens a module, reads four related files and works through a failing test over twenty turns. The opening turns write the cache. The middle turns are almost entirely reads plus a little new input. The final turns, if the model writes a large patch, become output-heavy.
The total may look like several million tokens. The expensive part is the patch, not the length.
What not to conclude
A high read count does not mean waste. It means the conversation was long. The waste appears when a long conversation is no longer serving the task, which is a different problem with a different fix.
Nor does a high count convert into a plan percentage. Anthropic does not publish a formula for that, so the product's own percentage remains the only reliable measure.
FAQ
Are cache reads free?
No, but they cost a fraction of normal input. The saving is large rather than total.
Why does my total climb so fast?
Every turn adds the conversation to the send. Cache reads make that cheaper, not free, and the count still accumulates.
Should I avoid long sessions?
Only when the context is no longer useful. A long session still doing relevant work is fine; a long session carrying dead ends is not.
The short version
Reads are cheap repetition. Watch output and fresh input for real cost, and read the plan percentage for the ceiling.