Notes6 min readDraft

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
  1. Where the repeats come from
  2. The model chart is a role chart
  3. The read-after-edit gap is mostly measurement
  4. Do newer models fix this?
  5. What I'd do about it

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

Redundancy rate by model (count = total reads). GPT-5.4 tops the chart with 80% redundancy across 10,730 reads.

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:

Redundancy rate by agent role (count = total reads). The role determines the rate, not the model.

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:

Read-after-edit rates by model and harness. Claude models: 11-23%. Codex models: 0.2-4%.
ModelHarnessEditsRead-after-editRAE rate
Opus 4.6Claude6,2591,43022.8%
Opus 4.5Claude5438415.5%
Sonnet 4.6Claude3,04935011.5%
Opus 4.7Claude2673513.1%
GPT-5.5Codex17374.0%
GPT-5.4Codex68971.0%
Codex (5.3)Codex84620.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:

Post-edit behavior: what agents do immediately after an edit, classified from transcript samples.
HarnessEditsRereadInline verifyGit diffTestNext edit/read
Codex (3 sessions)28051409
Claude (3 sessions)425001025

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.

Claude model generations. Opus 4.7 looks promising, but only 63 spawns.
ModelSpawnsRedundancyRAE rate
Opus 4.5 (Nov 2025)19857.3%15.5%
Opus 4.6 (current)1,20464.6%22.8%
Opus 4.7 (newest)6332.8%13.1%
Sonnet 4.5 (Sep 2025)4950.3%n/a
Sonnet 4.6 (current)64263.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:

Claude Code read-after-edit before and after April 3, 2026. The comparable roles require at least 25 edits on both sides of the cut.
SliceBefore editsBefore RAEAfter editsAfter RAEDelta (pp)
All Claude Code2,61921.1%10,94119.0%-2.1
coder32016.6%2,72419.1%+2.5
architect1,19024.4%6728.4%+4.0
reviewer57719.8%10322.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.