Agents · why latency compounds
One slow tool call. Seventy-one times.
An agent doesn't make one call and stop. It searches, reads the result, decides, searches again: a chain where every step waits on the one before it. So the speed of your file-search floor isn't a one-time cost. It is a cost the run pays on every hop, and it accumulates. On a real 4.47-million-file machine, one measured run to find a single file made 71 of them, and spent 6 minutes 57 seconds doing it.
The shape of a run
A run is a chain, not a burst.
Here is the part people miss. A web backend that needs fifty rows fires fifty queries at once and waits for the slowest: latency hides behind parallelism. An agent can't do that. It has to see each result before it knows what to ask next: the grep output decides which file to open, the file decides the next search. The calls are serial and dependent: a critical path with nothing to hide behind.
On a critical path, latency doesn't amortize. It adds. The run's wall-clock is simply the sum of every hop, so a floor that costs seconds per call doesn't cost you once: it multiplies by however many calls the task needs. Drawn on the time axis, one run looks like this.
Read it left to right along the clock. Each blue dot is the model deciding and reading, fast and cheap. Each red bar is the search it then has to wait on. On the slow floor the red bars tile the whole timeline and the running total climbs six seconds at a time; on the fast floor the same answer is already indexed, so the run collapses to a dot at the start line. The ≈6 s is the measured run's own average: 6 m 57 s across 71 calls; individual searches ranged from milliseconds to 93.8 s.
One task · measured, not modeled
We watched Claude Code find one file.
That was the full workflow: plan, search, narrow, repeat. Strip it down to a single isolated lookup on the same drive and the floor is no kinder: Claude Code took 193.5 seconds where the index returned the identical result in 85 microseconds, a 2,276,000× difference on one hop. End to end, the whole run came out about 7,200,000× apart. The model didn't change between those numbers. Only the floor under each of its calls did.
Same machine · same drive · same lookup
Per call is the number that becomes the run.
The per-call column is where the run is decided. A floor measured in seconds cannot produce a run measured in anything less than minutes, because the agent visits it dozens of times. A floor measured in microseconds stays invisible no matter how many times the agent asks: 71 indexed calls still finish inside a blink.
| The floor under each call | One call | What a run pays | vs Interlinked |
|---|---|---|---|
| Interlinked | 85 μs | ≈10 ms even at 71 calls | the baseline |
| VS Code · Ctrl+P | 35 s | seconds per file open, every time | 412,000× |
| Windows Search | 67 s | over a minute per query | ~480,000× |
| ripgrep · content | 93.8 s | one heavy query stalls the run | 58,625× on the set |
| Claude Code · full run | ≈6 s avg | 6 m 57 s across 71 calls | ~7,200,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Interlinked single-file lookup 85 μs (139 μs median of 20); the content query that took ripgrep 93.8 s returns in 16 ms (58,625× averaged across the five-query set, ~7 to 9 ms typical). The ≈6 s per call is the measured run's own average: 6 m 57 s across 71 calls; individual searches ranged from milliseconds to 93.8 s. Per-tool detail in the 412,000× write-up, the ripgrep comparison, and the Claude Code run.
Metered or capped: the leak compounds either way
The bill compounds. So does the cap.
The two most common ways to run an agent meet the same leak from opposite sides. How you pay only changes where you feel it.
CLAUDE CODE · PAY PER TOKEN
Every search result is appended to the conversation and re-read on every later turn. So a chain of 71 searches doesn't add 71 costs: it adds 71 walls of output that each get re-billed on every turn that follows. The harder the task, the longer the chain, the more the invoice grows against itself.
CLAUDE MAX · FLAT AGAINST A CAP
Same tokens, but they draw down a fixed window instead of an invoice. Every directory listing the model re-reads is allowance spent, so a long file-hunt chain means you hit the limit sooner and wait, having spent the reasoning capacity you pay for on ls output.
Why a slow floor hits you twice
This is why swapping in a bigger model doesn't help. A smarter model on the same slow floor makes the same 71 calls and waits on the same disk. You just pay more per second to wait. The bottleneck isn't the model's reasoning. It is the primitive underneath it, and the primitive is what you fix.
The fix · fix the floor, not the model
Make the slow hop free.
A live, always-warm index of every file on the machine (names and contents) collapses both factors at once. T drops from seconds to microseconds, because the answer is already built and waiting instead of walked on every query. And N drops too, because the result is the handful of files that actually match, not a grep dump the agent has to loop through to disambiguate. The chain that took 6 m 57 s over 71 calls becomes one call that returns in 16 ms.
NO MODEL IN THE LOOP: THE ENGINE IS AN INDEX AND A HASHMAP · EVERY ANSWER STAYS ON YOUR MACHINE, OFFLINE.
Do this today
Give every call a fast floor.
Install once. One signed installer auto-configures 19 AI clients (Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline and the rest) over MCP. No JSON to edit, no keys.
Let it index. Filenames are searchable immediately; contents fill in behind them. At rest the engine sits around 44 MB, and the index on disk stays under 1% of the drive.
Stay fresh for free. Save a file and it's searchable in about a millisecond (under 30 ms worst case), so no hop in the chain is ever waiting on a stale index.
Scope when you can. Whole-machine when you don't know where something lives; a folder when you do. Scoped queries return in microseconds either way.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.