What's new
Analysis14 Nov 20265 min read

A long document can cost you again on every turn

In a synthetic twenty-turn conversation, a 20,000-token starting prompt grows into 590,000 billed input tokens across the run, so window size and cumulative bill answer different questions.

Fitting inside a model's context window establishes capacity for one request, subject to the other material you send. It says nothing about what a conversation about that document will cost. That depends on the sequence of requests the application actually makes.

Anthropic's context-window guide, read on 14 November 2026, describes previous messages as part of later input and notes that cached prefixes still occupy the window. We use an explicit replay example here. It is an assumed application design, not a description of every chat interface.

The bill follows the requests, not the file

Our fictional application starts with 20,000 input tokens. It retains another 1,000 tokens between each request, representing the previous exchange, and sends the full retained history again. There is no caching, trimming or compaction. Input is priced at an assumed $1 per million tokens, with output charges left out.

The first request sends 20,000 tokens, the second 21,000 and the third 22,000. By the twentieth request, the individual input is 39,000. Across the whole run the inputs add up to 590,000. That total is spend accumulated across requests, not the size of a single window.

Illustrative full-history replay, input only, at an assumed $1 per million tokens. Baseline resends 20,000 tokens each turn without retaining additional history; it is not a tested substitute.
TurnsCumulative replay inputInput billFixed-prefix baseline tokensBaseline bill
120000$0.0220000$0.02
5110000$0.11100000$0.10
10245000$0.25200000$0.20
20590000$0.59400000$0.40

The fixed-prefix baseline shows where the growth comes from. At twenty turns it sends 400,000 tokens and costs $0.40. The replay run sends 190,000 more and costs $0.59. Removing that history would change what the model can see, so the difference is not a saving you can bank without checking the result.

A growing sum needs a different budget

For N turns, the initial prefix contributes 20,000 times N. The retained additions contribute 1,000 times the sum from zero to N minus one, which is 1,000 × N × (N − 1) ÷ 2. That second term is why multiplying the first request by the turn count understates this particular run.

Real conversations will not add exactly the same number of tokens on every turn. Some applications summarise history; others remove tool results or keep different reasoning blocks. Your application's actual request usage is a better guide than this example. A per-request series lets you trace a sudden jump to a file or tool response.

Space, cost and usefulness are separate checks

A capacity check asks whether the next request and its allowed response fit. A cost check adds billable usage across requests. A quality check asks whether the answer is supported by the material. They belong in separate columns of your own results log, since passing one does not establish the others.

With caching, the total context count stays and the cost splits into ordinary input, writes and reads. A summary needs a note of which material it replaces, plus test questions whose answers depend on that material. A smaller request is observable; whether it preserves the information you need takes another check.

For document work, a few questions that depend on small details and a few whose answers are absent make a useful set. Ask for the supporting passage and review it. This is a proposed test procedure, not evidence that a particular long-context model succeeds or fails.

When to stop the workflow

A budget for the complete job, checked against cumulative usage as it runs, gives the workflow a limit. Decide when to start a fresh conversation, narrow the documents or ask the user to choose a scope, and record the point of intervention so later tests compare the same workflow.

A million-token headline tells you about capacity. Your bill comes from the requests you actually send, which is a separate figure to follow.