Agents · token economics · measured July 2026
Your AI's biggest cost is the one you can't see.
You buy a coding agent by the token (a $200 Claude Max plan, an API bill, a seat) and you assume you're paying for reasoning. Mostly, you aren't. On one real session measured on a 4.47-million-file machine, Claude Code spent about 58% of its tokens before it wrote a line of your code, and not on any single expensive call. It leaked, quietly, across five places at once. None of them a line item. Here is each leak, and the math.
TL;DR · Key takeaways
Coding agents leak most of their spend on finding files, not reasoning: on one measured Claude Code session (Ryzen 9 9950X3D, 4.47M files), about 58% of the tokens went before a line of code was written.
The cost compounds: a file listing is re-sent and re-billed on every later turn, so locating one file took 71 tool calls and 6m 57s.
A live, always-fresh local index answers the same lookup once: 85 μs for a single file (139 μs median across the 4.47M-file drive), turning 6m 57s into 16 ms (~7,200,000× on that task).
It's a faster floor, not a smarter model: content search runs in 7 to 9 ms where ripgrep takes 93.8 s → 16 ms (58,625×), closing all five leaks at once: listings, failed greps, retries, re-reads, big context.
Fully offline, ~44 MB idle, ~1 ms to re-index a save. Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo.
The five leaks
Five places your tokens quietly leak.
A coding agent works in a loop: think, call a tool, read the result, repeat. The reasoning is what you want. The tool results are the tax, and most of the tax goes to one thing the model can't do on its own: find things on your machine. Ranked by how much they typically cost, here are the five, and how far each one falls once the agent can locate anything in a single indexed lookup.
Bars are ranked by typical impact; the internal split is illustrative. The measured anchor: on one real Claude Code session on the benchmark machine, the whole finding-things bucket (listings, failed greps, retries, and the re-reads and context they drag in) came to about 58% of the session's tokens. The muted bar under each leak is what survives once the agent stops walking the disk.
Why finding is the biggest leak
One listing, billed again and again and again.
File listings top the chart for a reason that has nothing to do with how big any one of them is. An agent's context is cumulative: every tool result is appended to the conversation and re-sent on the next turn, and the next. A directory dump you read once is re-billed on every step that follows it. So the cost isn't the listing: it's the listing multiplied by the turns it rides along in.
That is one file, on a machine with 4.47 million of them. A single Claude Code lookup with no index took 193.5 seconds, and the same disk-walking habit is what makes failed greps, re-reads and retries expensive too: each one adds to the context that every later turn pays to re-read. The leaks aren't five separate problems. They're one problem, billed five ways.
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. The agent run is the measured Claude Code session. The reasoning-versus-search share is a token count of that session, not a line on an invoice: usage doesn't map to dollars that cleanly, but the proportion is real. The engine latencies were re-validated in July 2026: crash-free, correct ranking, zero errors across roughly 1,500 queries.
The five, and what closes each
Each leak has the same root cause.
Four of the five trace back to the agent not being able to find things in one shot. The fifth (re-reads) is what happens when it can't remember what it already learned. Both are fixable without a smarter model.
| Leak | What it is | What closes it |
|---|---|---|
| File listings | ls / find / glob walking the disk to locate one file | One indexed lookup, whole-machine: 85 μs |
| Failed greps | queries that return nothing useful, or a wall of hits | Indexed content search: a hit or a clean miss in 7 to 9 ms |
| Retries | wrong-path guesses and tool errors, then a re-plan | The right file the first time, so there is no wrong-path loop |
| Re-reads | the same file read again after it fell out of context | Short notes that live on the file, handed to the next agent |
| Big context | every past tool result re-sent on every later turn | The hunt never enters the context, so there is less to carry |
The first four are one product idea: a live, always-fresh index of every file on the machine, names and contents, answered from memory. The fifth is the other half: short notes and relationships that live on the file itself and are fed back to the next agent on the searches it already runs, so it stops re-deriving what was already found. The same content query that takes 93.8 seconds on ripgrep returns in 16 ms here: a leak closed, not a model made smarter.
The fix, measured
Same plan. Same model. The 58% goes back to work.
Interlinked keeps a live, always-fresh index of every file on the machine: names and contents, every repo, including the files a project-scoped search never sees. The agent asks once and gets the answer, so the hunt never enters the context to be re-billed. On Claude Max, that is the difference between renting a frontier model to think and renting it to run grep.
THE FIX ISN'T A SMARTER MODEL. IT'S A FLOOR THAT ANSWERS IN MICROSECONDS.
Common questions
Questions, answered.
Does Interlinked use AI or send my files anywhere?
No. The lookup is an index and a match: no models, no keys, no cloud calls, and nothing leaves the machine. That's how a single-file lookup lands in 85 μs while the whole engine idles at around 44 MB.
How is this different from ripgrep or my editor's search?
Those walk the disk on every query; Interlinked answers from a prebuilt, always-fresh index of the whole machine. The same content search that takes ripgrep 93.8 s returns in 16 ms here (about 58,625× faster) and a single filename lookup is roughly 412,000× faster than VS Code and 480,000× faster than Windows Search.
Won't the index be stale the moment I change a file?
No. A save is searchable again in about 1 ms, and under 30 ms in the worst case, so an agent never queries a stale index.
How does faster search actually lower my token bill?
It keeps the hunt out of the context. On the measured session, locating one file cost 71 tool calls, 6m 57s, and about 58% of the session's tokens; with the index it's a single call in ~16 ms, so that ~58% drops toward ~0% and goes back to reasoning.
What does it cost, and what do I have to set up?
Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo. One signed installer wires up 19 AI clients with no JSON editing and no keys.
Do this today
Stop paying to look for files.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Codex, Copilot, Windsurf, Zed, Cline and the rest. No JSON editing, no keys.
Let it index. Filename search works immediately; content search fills in behind it. At rest the whole engine sits around 44 MB (less than a browser tab) and its index takes under 1% of the drive.
Scope when you can. Whole-machine when you don't know where something lives; scoped to a folder when you do. Either way the answer is one tool call, not seventy-one.
Let the notes build. As agents leave short notes on files, the next one stops re-reading to re-learn what was already found. The re-read leak closes on its own.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. No AI, no keys, no metered lookups, and the index never leaves your machine. Download for Windows.