324 million tokens re-read for 3 million written: what an agent session really costs

I am a web developer. I read technical books and write reading notes on them, summaries published in the library of this site. I make them with Claude, but never with a single instance. I use a small team of agents: Claudes that each have a role, such as reading, writing or reviewing. Each agent consumes tokens, the pieces of words Claude reads and writes. That is what drains my subscription.

My first two reading notes, short ones, written before these measurements, used 4.1 million agent tokens. That is about 360 tokens for every word the reader ends up reading. I wanted to know what I could cut without hurting quality. So I measured four more reading notes, step by step. The result: two things brought the bill down. The first is a script, a small ordinary program with no AI, placed before an agent. The second is to relaunch the same agent after a correction: it picks up where it left off, instead of starting over. Shortening the notes taken by the agents that read the book cut the total by 12%, but gained nothing per published word. A third script, the one that checks quotations, is not part of this count: I did not measure its gain.

$ git clone https://github.com/ohugonnot/citecheck
$ cd citecheck && ./demo.sh

How a reading note is written, then graded

A reading note sums up a technical book in a few minutes of reading. Claude agents write it, but never alone: the agent that writes is not the one that judges. An author re-reads what they meant to write, not what they wrote (No Agent Grades Its Own Homework).

The reviewer compares the note to the book's text and gives a score out of 100. One part, fidelity, is worth 25 points: real examples, exact quotes, nothing invented. Below 20 out of 25, the note goes back for correction, whatever the total: a 19/25 is rejected even with 90 out of 100. To get out, it also needs 85 out of 100 overall, fidelity included. I allow the reviewer three rounds, a medium-sized Claude called Sonnet. A final review then goes to the largest, Opus.

What the usage really shows

Claude Code, the tool I use to run my agents, has a command, /usage, that shows what a session has consumed. I ran it after seven hours of work. It showed 107 dollars and 14%. The 107 dollars are an amount computed by the tool, not a bill: I pay a monthly plan. The 14% is the share of this week's quota already used. That subscription has a weekly limit, like a plan of minutes.

The report also held a strange figure: 323.7 million tokens re-read, for only 2.9 million tokens of text produced. A token is a small piece of a word, the unit in which Claude reads and writes. "Re-read" means read again by an agent, in the middle of its work. My agents therefore re-read more than a hundred times what they wrote.

Why so many re-reads? An agent works by asking tools to act: opening a file, running a program. Each request to a tool is called a call. The agent keeps no memory of itself from one call to the next.

To let it follow the thread, it is therefore sent the whole conversation from the start on every call. That conversation is called its context. Picture a colleague who must re-read their whole notebook from page one before writing each new line. The bigger the notebook gets, the more each line costs in reading.

The cache keeps the start of the conversation ready to be reused (Anthropic documentation). A re-read from the cache costs less than a fresh read, but it is not free: it still appears in the report, and there are 323.7 million of them.

The report does not break down the 107 dollars. So I cannot say how much comes from re-reads. They are a hundred times more numerous than the text written: I infer that the weight comes mostly from them. That is an inference, not a measurement.

Two precautions. First, this report covers my whole session, not one reading note alone. Second, my agents report back their own token counters, the ones in the rest of this article. They also count this re-read context. They do not match what my subscription deducted.

I ran /usage again after the last of the four reading notes. Between the two reports, I also read the diagrams of another book, built this article's repo, and wrote its first draft. The displayed cost went from 107.05 to 120.96 dollars, 13.91 more for 1h 07 of work. The week went from 14% to 15%: about one point, as the display does not give more precision.

The chain, step by step

Claude comes in three sizes. Haiku, the smallest, is the cheapest per token. Sonnet, the middle one, does almost everything. Opus, the largest, is the most expensive. For each agent, I give the size it used.

A reading note goes through about ten agents, in this order:

• a planner agent (Sonnet during these measurements, Opus since) picks the chapters to read and the key ideas to keep;
• three readers (Sonnet) read those chapters of the book and take notes;
• a writer (Sonnet) writes the reading note from the notes;
• a novice reader (Haiku) flags anything a developer who has not read the book does not understand;
• a corrector (Sonnet) applies its report and edits the text;
• a reviewer (Sonnet) rereads the reading note without editing it: it checks each claim against the book, and a few facts on the internet;
• if the reviewer finds defects, the corrector and the reviewer go back for a second round;
• a translator (Haiku), then an agent (Sonnet) that builds the web page;
• finally, when style defects remain, a final review by Opus, which I did not run on the last two reading notes.

Between them, there are scripts. A script is not an agent: it consumes no tokens. One of them checks the quotes, the passages of the book copied between quotation marks into the reading note, before each review.

Here are the four reading notes measured side by side. In the table, "M" means million. The first two rows are reading notes already online, not the two short ones at the start: Event-Driven Architecture in Golang and Observability Engineering. The fourth, Building Secure and Reliable Systems (Heather Adkins et al., Google and O'Reilly, 2020, free online), cost 1.42 million agent tokens. "Reading" counts the tokens used to read the book and take notes. "First draft" counts those of the first version of the text. "Fidelity" is the score out of 25 explained above. The third, Serious Cryptography, is a book by Aumasson on cryptography.

The two short reading notes at the start cost about 360 tokens per published word. Read with caution: four different books, one measurement per reading note. These are orders of magnitude, not an average.

What paid off: the script goes before the agent

First gain: choosing what to read. Before reading a book, you must decide which ideas to keep and which parts to read. That is the job of the plan agent, seen in the list above. My old method did it in two passes. The first, a quick look called the pre-sort, cost 93,700 tokens. The second, a fuller analysis called the sort, cost 109,900. That made 203,600 tokens. I had planned 25,000 for the pre-sort. Why so much? On every call, the agent re-read the site library's index. The index is the list of all the reading notes already published: the agent used it to know which ones already exist. Since it re-reads everything on every call, that index was expensive.

A script now builds it in one second, and another maps the book, one line per chapter. A single agent, the planner, chooses from those two lists. It costs 81,600 tokens on the third reading note, 68,300 on the fourth, measured on Sonnet. I have since moved it to Opus, which costs more per token, because it decides what the reading note will contain: an idea it forgets, no review will catch. I have not yet measured what this costs.

Second gain: when the reviewer finds defects, I do not launch a new agent. I relaunch the same one, with the exact list of defects. It picks up the same conversation: what it has already read is there, and it only looks at what changed since its first pass. A new agent would have to re-read everything from zero, the book included. On the fourth reading note, the corrector cost 30,700 tokens on the second round, against 169,100 on the first. The reviewer: 21,700 against 174,200.

Third addition, whose gain I did not measure: a script reads the quotes before the reviewer does. It only judges what is between quotation marks. In a reading note, a quote is followed by a reference, for example "(chapter 3)". The script looks for the quote in the book's full text, at the place announced. It catches three kinds of errors my reviewers used to find themselves. One quote is slightly rewritten. Another is attached to the wrong chapter. One reference points to a chapter that does not exist. It costs no tokens. Here is what it answers, without its header line, on a deliberately false reading note written for a book invented for the repo. That book is in English, hence the English quotes. In its output, "lesson" and "unit" mean chapter.

ECHEC  l.7 (lesson 9) : leçon 9 n'existe pas dans la source
ECHEC  l.3 (lesson 1) : introuvable « 99 to 100 percent »
MAUVAISE-UNITE l.5 (lesson 3) : « dirty lines are a debt, not a gift » est en leçon [2]
a-verifier l.3 (lesson 1) : nombre 300 absent de l'unité citée | …. A miss to main memory costs about 300 cycles against 4 for a hit
RESULTAT : ECHEC (3 échec(s), 1 nombre(s) à relire)

• ECHEC, l.3 (line 3 of the reading note): the quote "99 to 100 percent" is not in the book. I had changed it.
• MAUVAISE-UNITE: the quote exists, but in lesson 2, not lesson 3.
• ECHEC, line 7: the reading note cites lesson 9, and the book only has three.
• a-verifier: the number 300 is not in the book. It is a warning to reread, not a refusal.

Full file: examples/summary-bad.md, lines 3 to 7 (the script's messages are in French)

It never refuses a number missing from the book, because the reading note may have computed it.

Yet the script only judges what is in quotation marks. The reviewer of the fourth reading note found five factual errors, and none was a quote from the book. The reading note's hook said the book was "silent on AI", yet it has a section on AI in chapter 2. One idea spoke of "the number of teams affected", whereas the book talks about dependencies, not teams. On these errors, the script stayed silent, and the reading note was wrong.

What I saved badly

On the third reading note, the three readers returned 23,800 words of notes. On the fourth, I capped the notes at 450 words per idea: 4,322 words in all. In the table, the reading costs 37% less. The first draft, the first version of the text, costs 41% less, for 18% fewer words. A gain, on the surface.

But the reviewer gave it 19 out of 25. Below 20, I have it corrected before publishing. The writer had paraphrased details by guesswork, for lack of rich enough notes. After correction: 23/25. Overall, the fourth reading note costs 12% less than the third, but per published word there is no gain: 209 tokens for the fourth, 199 for the third. I moved work from the readers to the reviewer, I did not remove it.

Another model choice: Haiku, the smallest of the three, has a far cheaper token. Its token total therefore says almost nothing about its cost. My novice reader on Haiku found 3 of the 4 unclear passages the reviewer later spotted. The translator on Haiku passed my checks, with 18% more tokens per word than Sonnet. Across my two reports, all of Haiku's work weighed 0.37 dollars, against 13.54 dollars for Sonnet. For these two tasks, it is worth it.

My take: what I would do again

My take: capping the readers' notes cuts the total by 12%, with almost no gain per published word. Without notes, the writer has nothing left to check against. I keep the cap, with an extra rule to test. Every figure and every claim attributed to the book keeps its quote in the notes, even when the rest is short.

The solid savings are the ones I measured. There is the index built by script, which brought the choice of reading from 203,600 down to 81,600, then 68,300 tokens. There is also the second round of the same agent. Quote checking costs nothing, but I did not measure what it saves. From now on, I reserve the reviewer for claims without quotation marks, the only ones the script cannot see. I did not run the final Opus review on the last two reading notes. After the second round, the reviewer flagged no style defect left to hand to Opus. I do not yet know whether those two reading notes lose quality.

Conclusion

What costs is not writing: it is re-reading. My safe savings, the ones I measured, hand a program what it can do alone. It keeps the index and draws the map of the book.

But a program stops where meaning begins. My quote script knows a sentence is in the book. It does not know that a book is not "silent on AI". I only found that border by measuring: capping the notes looked like a gain, and had only moved the work to the reviewer. Before cutting a step, I now measure what it catches, not only what it costs.

Sources

Measurements from 3 November 2026:

• Documentation consulted on 3 November 2026: costs in Claude Code (the /usage command) and the cache ("prompt caching").
• The code and tests: citecheck repository, frozen version of the code (commit e875dd3).
• The two reading notes of the table already online: Event-Driven Architecture in Golang and Observability Engineering.
• Token figures come from my session's agent reports. Dollars and percentages come from the /usage command, read twice the same day.