Resuming a session costs 43,350 tokens once, then 293 a turn

The tool round trip measurements are alarming read on their own: every tool call re-sends your entire context, and a session can run to millions of tokens. It is worth saying clearly what that does not mean, because conversation turns behave completely differently.

Continuing a conversation costs 293 tokens a turn.

The pattern

Six consecutive --continue turns on the same conversation, each asking for a one-word reply:

Turn	Cache created	Cache read	Total prompt	Reported cost
1	293	60,222	60,515	$0.0332
2	293	60,515	60,808	$0.0333
3	293	60,808	61,101	$0.0334
4	293	61,101	61,394	$0.0336
5	293	61,394	61,687	$0.0337
6	293	61,687	61,980	$0.0339

Every row writes exactly 293 tokens, and every row’s read is exactly the previous row’s total. Only the new material is cached; everything before it is read back.

Over six turns the context grew by 1,465 tokens and the reported cost rose from $0.0332 to $0.0339, about 2%. A conversation does not get dramatically more expensive as it grows, because the part that grows is served from cache.

The 293 figure is the cost of that specific exchange, a short prompt and a one-word answer. A turn that produces a page of code writes proportionally more. The structure is the point: you pay a cache write for new content once, then read it cheaply forever.

The first resume is not free

Starting to resume is a different matter. In a fresh project, warming a session and then continuing it:

Step	Cache created
claude -p (first ever, cold)	43,065
claude -p again (warm)	0
first --continue	43,350
--continue again	293
--continue again	293

The first --continue rebuilt the cache in full, 43,350 tokens, even though the run immediately before it was warm. Reproduced in a second project at 43,637.

The reason is that resuming prepends the prior conversation, which changes the shape of the cached prefix. Once that new shape is established, the incremental pattern takes over.

So the cost of picking a conversation back up is a one-off rebuild, not a per-turn tax. This is the same shape as effort levels, where the first use of a level costs a full write and everything after is free.

What this corrects

Reading the round trip post alone, it would be easy to conclude that long sessions are ruinous. They are not, and the distinction matters:

	What it costs
A conversation turn with no tool call	one context read, plus a cache write for what is new
A conversation turn with a tool call	two context sends, because the tool result triggers a second API call

Round trips multiply your context. Conversation turns do not. The million-token session totals in that post come from tool calls, not from talking.

It is also why token counts and dollar costs diverge so sharply. Turn 6 sent 61,980 prompt tokens for $0.0339, while a cold run sending fewer tokens cost $0.44, roughly 13x more for less material, purely because it was writing cache rather than reading it.

Scope

One project, trivial one-word turns, Claude Code 2.1.224. The 293-token figure is specific to that exchange size; the linear structure and the one-off resume cost are what transfer. Absolute cache figures depend on your own context size, and the baseline here included a large user-level CLAUDE.md, discussed on the calculator.

Both findings reproduced: the 293 constant held across all six turns in one project and the first three turns of another, and the cold first resume reproduced in two separate projects.