75% of LLM Reads Are Redundant
I scraped 3 months of AI agent sessions across Claude Code, Codex, and OpenCode. 75% of file reads were redundant.
Contents
75% of LLM Reads Are Redundant
I’ve been running AI coding agents heavily since February: Claude Code, Codex, OpenCode, plus a multi-agent orchestration engine I built on top of all three. After a particularly expensive overnight session, I wanted to understand my usage at scale. Not just one bad spawn. Everything.
I wrote a script that pulls tool-call history from every session across all three harnesses. Claude Code stores sessions as JSONL. Codex has its own event format. OpenCode writes to SQLite. The script normalizes all three and extracts every file read: Read tool calls, cat and sed in bash, grep and rg. Then it checks whether the agent had already seen that file earlier in the same session.
The dataset covers 4,339 sessions from February through May 2026, across a dozen models, three harnesses, and 30+ agent roles.
75.1%
of file reads were redundant
50,319 of 67,017 reads across 4,339 sessions
Three out of four file reads were repeats. The agent read a file, kept working, then read the same file again later in the same session.
Where the repeats come from
Read-edit-reread is the biggest source. An agent reads a file, edits it, reads it back. I found 2,197 read-after-edit events across the dataset. The worst single session had 76.
Delegation restarts context. My setup spawns agents from agents, and each spawn starts with a fresh context window. The parent already read the files and knows what matters; the child starts blind and reads them again. Some of that is the price of delegation. The open question is how much a better handoff (file contents passed in the spawn, or prewritten .context/ notes) would save.
Compaction creates amnesia loops. The agent fills its context, compacts it into a lossy summary, forgets the file contents, re-reads them, and fills the context again. Sessions that compacted averaged 67 reads and cost $20.16. Sessions without compaction averaged 13 reads and $1.13. One session compacted 29 times.
The model chart is a role chart
GPT-5.4 at 80% redundancy. GPT-5.5 at 30%. It looks like newer models learned not to re-read.
Then I sliced the same data by agent role:
The spread tracks the role, not the model. GPT-5.4 was my leaf coder and reviewer: reading, editing, and re-reading all day. GPT-5.5 was my orchestrator, and orchestrators delegate instead of reading. GPT-5.4-mini was my explorer, which reads files, writes a report, and stops. Redundancy follows how much editing a role does.
The explorer number still stood out. 42% is high for a role that should read once and report. When I dug in, the cause was compaction: explorers filled their context, compacted, lost the files they had read, and read them again. That’s what led me to build .context/CONTEXT.md files: prewritten notes colocated with the code, so an explorer can understand a module from a few hundred lines of markdown instead of 20 source files. I also started scoping each explorer to a single question and fanning out several cheap spawns instead of one that reads everything. Both changes cut the compaction-driven re-reads significantly.
The read-after-edit gap is mostly measurement
My read-after-edit (RAE) metric counts how often an agent re-reads a file right after editing it. It split sharply by harness:
| Model | Harness | Edits | Read-after-edit | RAE rate |
|---|---|---|---|---|
| Opus 4.6 | Claude | 6,259 | 1,430 | 22.8% |
| Opus 4.5 | Claude | 543 | 84 | 15.5% |
| Sonnet 4.6 | Claude | 3,049 | 350 | 11.5% |
| Opus 4.7 | Claude | 267 | 35 | 13.1% |
| GPT-5.5 | Codex | 173 | 7 | 4.0% |
| GPT-5.4 | Codex | 689 | 7 | 1.0% |
| Codex (5.3) | Codex | 846 | 2 | 0.2% |
Claude Code agents re-read after 11–23% of edits. Codex agents: 0.2–4%. A 10–100x difference, consistent across every model in each harness and every week in my time-series tracker.
I didn’t trust it. So I pulled 3 Codex coder sessions and 3 Claude coder sessions and classified what happened immediately after every edit:
| Harness | Edits | Reread | Inline verify | Git diff | Test | Next edit/read |
|---|---|---|---|---|---|---|
| Codex (3 sessions) | 28 | 0 | 5 | 14 | 0 | 9 |
| Claude (3 sessions) | 42 | 5 | 0 | 0 | 10 | 25 |
Codex agents had zero explicit re-reads, but 5 inline verifications (a read-back inside the same bash command) and 14 git diff checks. Claude agents re-read after 5 of 42 edits and ran tests 10 times. Both verify their edits. They use different mechanisms. Claude Code’s separate Read and Edit tools make verification a distinct tool call that my analyzer counts. Codex edits through bash, so verification hides inside the same command or a git diff, where a tool-call parser can’t see it.
A git diff after 12 edits is one command. Twelve Read calls after twelve Edit calls is 24 tool round-trips. The tool interface shapes what you can measure as much as what agents do.
Do newer models fix this?
I can’t tell.
| Model | Spawns | Redundancy | RAE rate |
|---|---|---|---|
| Opus 4.5 (Nov 2025) | 198 | 57.3% | 15.5% |
| Opus 4.6 (current) | 1,204 | 64.6% | 22.8% |
| Opus 4.7 (newest) | 63 | 32.8% | 13.1% |
| Sonnet 4.5 (Sep 2025) | 49 | 50.3% | n/a |
| Sonnet 4.6 (current) | 642 | 63.3% | 11.5% |
Opus 4.7 has the lowest redundancy of any Claude model (32.8%) and a lower RAE rate than 4.6. But that’s 63 spawns, mostly design work. Opus 4.6 looks worse than 4.5, but 4.6 was my workhorse coder and 4.5 did design and orchestration. GPT-5.5’s 29.5% comes almost entirely from orchestrator runs. To compare models fairly I’d need to run them in the same role on the same tasks.
What the data does show: no model, on any harness, in any role, drops below 30% redundancy. The best case still re-reads about a third of its files.
Anthropic noticed the pattern too. Recent versions of Claude Code’s Read tool inject an instruction not to re-read a file right after editing it, since Edit would have errored if the change failed. I found it in the tracked system prompt history. It’s injected through a template variable (ADDITIONAL_READ_NOTE) made configurable in v2.1.91 on April 3, 2026, so it may be model-dependent or feature-flagged, and I can’t tell which of my sessions had it.
RAE only measures what it claims to on Claude Code, so that’s where I tested it. I cut the Claude Code data at the v2.1.91 release date:
| Slice | Before edits | Before RAE | After edits | After RAE | Delta (pp) |
|---|---|---|---|---|---|
| All Claude Code | 2,619 | 21.1% | 10,941 | 19.0% | -2.1 |
| coder | 320 | 16.6% | 2,724 | 19.1% | +2.5 |
| architect | 1,190 | 24.4% | 67 | 28.4% | +4.0 |
| reviewer | 577 | 19.8% | 103 | 22.3% | +2.6 |
The aggregate drops from 21.1% to 19.0%. The comparable roles go the other way: coder, architect, and reviewer all re-read more often after the cut. The post-release data also includes many roles that didn’t exist before it. I wouldn’t claim the instruction helped.
What I’d do about it
Prompting against re-reads hasn’t clearly worked, and some re-reading is reasonable: an agent that just edited a file wants to know what’s in it now. The waste is in where the file contents live. Every read appends another full copy of the file to the conversation, compaction throws those copies away, and the agent reads the file again.
I think the harness should hold the current contents of active files and stop storing them as transcript history. I wrote that up as a proposal, with prior work and an experiment design, in A working-memory cache for agent file reads.
4,339 sessions across Claude Code, Codex, and OpenCode, February through May 2026. 12 models, 30+ agent roles. What Happened to My Tokens? is the case study that started this analysis.