Reading a 6-byte file costs 58,851 tokens

Everything measured on this site so far has been startup cost: what your CLAUDE.md, skills and MCP tools cost before you type anything. This is the other half of the budget, and it is bigger.

In a project whose startup context is 58,699 tokens, asking Claude Code to read a 6-byte file brings the session total to 117,550. The read costs 58,851 tokens, and six of those are the file.

A tool call costs roughly your entire context, again

Operation	Total tokens	Over baseline
No tool call	58,699	—
Read a 6-byte file	117,550	+58,851
Read a 10KB file	121,038	+62,339
Read a 40KB file	131,485	+72,786

The reason is architectural rather than surprising once stated: a tool call is not one request. Claude Code sends the conversation, gets back a request to run a tool, runs it, then sends the whole conversation again with the result appended. Two API calls, each carrying everything.

So the marginal cost of a tool call is approximately the size of your current context. Not the size of what the tool returns.

That also means the content is the cheap part. Subtracting the round trip, file text lands at about 0.35 tokens per byte, consistent across the 10KB and 40KB reads. On the 40KB file the round trip is 58,851 tokens and the file itself is 13,935. The overhead is four times the payload.

Batching the same work halves the cost

If each round trip costs a full context re-send, then the number of round trips is the thing to control. Reading three files, identical files and identical results, differing only in whether the calls were issued together:

How the three reads were issued	Total tokens
Batched into one parallel block	121,732
Strictly one at a time	240,073

Both figures reproduced exactly across two runs. The sequential version costs 1.97x the batched version for the same work, a difference of 118,341 tokens.

This is not specific to Read. The same test with Bash:

Three echo commands	Total tokens
One parallel batch	117,753
One at a time	235,446

Two point zero times, on commands whose combined output is six bytes. The tool does not matter. The number of round trips does.

What to actually do with this

Ask for work in batches. “Read these four files” costs one round trip. “Read this file” four times over costs four. If you know up front which files you need, name them all in one message.

Front-load the discovery. A Grep that finds the six relevant files, followed by one batched read of those six, is two round trips. Reading files one at a time to work out which matter is one round trip each.

Keep your baseline small, because you pay it repeatedly. This is where startup cost and per-operation cost multiply together. A bloated CLAUDE.md is not charged once, it is charged on every tool call for the rest of the session. Trimming 5,000 tokens of startup context saves 5,000 tokens on every round trip, and a working session easily runs to dozens.

That last point reframes the earlier measurements. The 1,845x difference between putting reference material in CLAUDE.md versus a skill body is a per-round-trip difference, not a per-session one.

Scope and caveats

The absolute figures are for one project with a 58,699-token startup context on Claude Code 2.1.224. Your round-trip cost will be whatever your own context is, which is exactly the point: the number to remember is not 58,851, it is “one tool call ≈ one whole context.”

Most of those re-sent tokens are cache reads rather than fresh input, so the dollar cost is far lower than the token count suggests. Reported cost per run varied with cache state even when token counts were identical to the digit, which is why this post quotes tokens rather than dollars.

One measurement note: num_turns is not a proxy for API calls. Both the batched and sequential three-read runs reported num_turns: 4, while their token totals differed by a factor of two. Count round trips by token arithmetic, not by the turn counter.

Every figure reproduced across at least two runs, with the baseline measured in the same batch.

---

Clarified 2026-08-08. The baseline figures in this post were measured on a machine with a large user-level CLAUDE.md, which loads into every session. That file was separately measured at 26,763 tokens, so Claude Code’s own floor is closer to 31,400 with tool search on. Every delta in this post is unaffected, because each was measured as a paired before-and-after on the same machine and the global config cancels out. Only the absolute baseline numbers are specific to that setup. The calculator now takes user-level config as a separate input.

Corrected again 2026-08-13. The ~31,400 floor quoted just above was itself too high. It was the loaded measurement minus that one file, which left this machine’s user-level skills, MCP servers and plugins sitting inside the supposed floor. Measured directly on 2.1.229, in an empty directory with --setting-sources project so nothing user-level loads at all, Claude Code’s own floor is 22,340 tokens with tool search on and 40,144 with it off, twice per round across four rounds with 0 to 4 tokens of noise. The deltas in this post remain unaffected, and that is now measured rather than asserted: the tool-search gap came back at 17,804 against the 17,795 the old pair implied, 0.06% apart. See the calculator for the full decomposition.