The Context Tax: AI agents read 140 times more than they write
Six months of production logs from three working AI agents. The answers they produce are under 1% of what they process. The rest is the agent re-reading its own conversation, and that re-reading grows faster than the work.
An AI agent's bill is driven by how long its jobs run, not by how much it says. Jobs of 16 steps or more were 29.4% of the work and 68.3% of the reading.
Writing is under 1% of an agent's work
The agents read 1.36 billion tokens and wrote 9.7 million. Writing was 0.71% of everything the models processed. Of the reading, 1.24 billion tokens were context re-sent from earlier steps and served from the provider's cache. Only 126.8 million were new. Even counting new material alone, the agents took in 13.1 tokens for every token they produced.
Every step of an agent job sends the model the whole job so far: the instructions, the tools, every file it opened and every answer it got back. The model writes an average of 414 tokens per step, then the next step sends all of it again, plus the new part. That re-reading is the context tax, and it is the largest line in these agents' workload.
Counted from the agents' own usage ledgers
The agents run on Hermes Agent, which records the provider's token counts after every model call. The counts land in each agent's local database as four counters per job and model: fresh input, cached input, cache writes and output. Hermes stores fresh input with cached tokens already subtracted. That makes the counters additive.
read(job) = fresh_input + cached_input + cache_write
written(job) = output
steps(job) = number of model calls in the job
growth = slope of log(read) on log(steps), least squares across jobsA job is one agent session: a scheduled report, a chat request, a hands-on working session or a sub-agent sent to do one piece of a larger task. A step is one call to the model. Single internal helper calls (title writing, memory lookups) are not jobs. The 3,019 of them are excluded from every job figure. Including them moves the overall ratio to 111.4 : 1.
Three scripts produce every number on this page: extract.py reads the databases read-only and writes jobs.csv (counts only, no message text). analyze.py computes results.json. build.py writes the figures into this page.
Three agents, six months, real business work
| Agent | Period | Jobs | Helper calls (excluded) | Model calls |
|---|---|---|---|---|
| Operator agent (general business work) | 2026-05-16 → 2026-11-11 | 1,277 | 3,017 | 25,576 |
| Client reporting agent A | 2026-09-11 → 2026-11-06 | 343 | 2 | 2,978 |
| Client reporting agent B | 2026-10-02 → 2026-11-09 | 83 | 0 | 975 |
The agents ran on hosted frontier models and on a 27-billion-parameter model on local hardware. They did the work of a small consultancy: research, writing, scheduled client reports, code and site changes, and sub-agents doing pieces of each. The study covers 8,282 usage records grouped into 4,722 sessions, from 2026-05-16 to 2026-11-11.
A third of the jobs do two thirds of the reading
Jobs of 16 steps or more were 501 of 1,703 jobs (29.4%). They did 68.3% of all reading and 52% of all writing. The heaviest 10% of jobs alone did 41.8% of the reading. Jobs of one to three steps were 12.4% of the work and 0.5% of the reading.
The typical job of 32 steps or more read 2,752,260 tokens. The typical job of one to three steps read 19,590. That is 140 times as much reading.
| Steps per job | Jobs | Median read per job | Median read per step | Read per token written | Share of all reading |
|---|---|---|---|---|---|
| 1-3 | 212 (12.4%) | 19,590 | 10,971 | 45.7 : 1 | 0.5% |
| 4-7 | 340 (20.0%) | 159,314 | 29,269 | 68.6 : 1 | 4.2% |
| 8-15 | 650 (38.2%) | 539,810 | 49,419 | 99.9 : 1 | 27.0% |
| 16-31 | 390 (22.9%) | 1,178,968 | 60,026 | 149.9 : 1 | 36.2% |
| 32-63 | 92 (5.4%) | 2,561,920 | 66,954 | 207.8 : 1 | 20.8% |
| 64+ | 19 (1.1%) | 6,032,758 | 66,404 | 393.2 : 1 | 11.3% |
Each step costs more than the one before, until the ceiling
In a short job the model reads a median 10,971 tokens per step. In a 16-to-31-step job it reads 60,026, 5.5 times as much for every single call. Past 32 steps the figure holds flat at 66,954 and 66,404, below the 100,000-token compression limit configured for these agents.
The ratio of reading to writing climbs with it: 45.7 : 1 in short jobs, 393.2 : 1 in jobs of 64 steps or more, a 8.6-fold rise. A long job produces more, but it re-reads far more to do it.
Double the steps, multiply the reading by 3.1
Across all 1,703 jobs, total reading rises with steps to the power 1.61 (R² 0.86). Work that grew in step with its steps would sit at 1.0. Doubling a job's length multiplies its reading by 3.1.
The pattern holds in every agent and in every kind of job. Among jobs up to 15 steps, where context is still filling, the exponent is 1.75. Among jobs of 16 steps or more, where context sits near the compression limit, it falls to 1.2: reading per step stays high and stops climbing.
| Group | Jobs | Growth exponent | R² |
|---|---|---|---|
| Hands-on sessions (terminal) | 185 | 2.02 | 0.92 |
| Sub-agents spawned by another agent | 1,003 | 1.33 | 0.9 |
| Scheduled jobs | 243 | 1.49 | 0.88 |
| One-shot tasks | 208 | 2.06 | 0.92 |
| Chat (Telegram) | 33 | 1.73 | 0.91 |
| API requests | 24 | 1.48 | 0.9 |
| Operator agent | 1,277 | 1.44 | 0.85 |
| Client reporting agent A | 343 | 1.71 | 0.89 |
| Client reporting agent B | 83 | 1.82 | 0.87 |
Budget for the steps, not the answers
Price agent work by how long it runs. The answer an agent hands back is 0.71% of what it processed. A quote, budget or vendor comparison built on "how much will it write" misses the line that dominates.
Caching is a requirement, not an option. 90.7% of all reading here was context the provider had already seen and served from cache. A setup without caching processes every one of those tokens again as new input. Ask any AI vendor whether repeated context is cached, and at what rate it is charged.
Split long jobs. Jobs of 16+ steps were 29.4% of the work and 68.3% of the reading. Every step added to a long job re-sends everything before it, so the long tail is where the reading piles up.
Cap the context. These agents compress their working history at 100,000 tokens, and per-step reading levels off below it. An agent with no ceiling keeps climbing.
Read the meter before scaling. Hermes records these four counters for every job. One query on them shows where the reading goes, which jobs run long, and what a tenfold rollout does to the bill.
Frequently asked questions
What does an AI agent spend most of its tokens on?
Re-reading. Across 1,703 production jobs the agents read 140.3 tokens for every token they wrote, and 90.7% of the reading was context the agent had already seen earlier in the same job.
Why do long AI agent jobs cost so much more?
Every step re-sends the whole conversation so far. Jobs of 16 or more steps were 29.4% of jobs and 68.3% of all reading. Doubling a job's steps multiplied its reading by 3.1 on average.
How do you keep AI agent costs under control?
Use a provider and setup that caches repeated context, split long jobs into short ones, cap the context with compression, and read the agent's own usage counters before scaling it.
Limits
This is one operator's three agents, on one agent framework, over six months. The figures are tokens, not dollars: the agents ran on subscription plans and local hardware, so the ledgers carry no per-token charges, and this page converts none. The growth exponent compares different jobs, not the same job run at different lengths. Jobs that run long also tend to be different kinds of work. The per-step plateau sits below the configured compression limit; this study does not isolate compression as its cause. A provider accounting fix on 2026-09-18 was checked: the fresh-to-cached ratio is 0.137 before it and 0.132 after. No message text, prompts, client names or client data appear in the published files.
Cite as: Christell, Patrick (2026). “The Context Tax: AI Agents Read 140 Times More Than They Write.” ICONIC Research. https://iconic.onl/research/agent-context-tax/