Agents · measured July 2026 · 6 min read
How many tool calls to find one file?
We counted. On a real 4.47-million-file machine, Claude Code (Anthropic's own agent, running its strongest model) made 71 tool calls over 6 minutes 57 seconds to open a single file. Point the same agent at the same machine with a live index and the job is one call, 16 milliseconds. This is the story of the other seventy: why each blind call compounds into minutes, tokens, and real dollars, and why the fix isn't a smarter model.
TL;DR
The count, and the fix, in five lines.
- On a 4.47-million-file machine, Claude Code (Anthropic's strongest model) spent 71 tool calls over 6m 57s to open one file. With a live index it is one call, 16 ms, about ~7,200,000× faster.
- The count is set by the tools, not the model: list, grep and read each rule out one spot, so finding one file among millions takes many blind probes.
- Every call re-reads the growing transcript, so cost compounds: the hunt burns ~58% of the session's tokens. An indexed lookup burns ~0%.
- An indexed filename lookup is 85 µs (139 µs median), about 412,000× faster than VS Code and ~480,000× faster than Windows Search (67 s). Content search runs in ~7-9 ms where ripgrep takes 93.8 s (up to 58,625×).
- The index stays fresh within ~1 ms of a save and idles at ~44 MB. Everything local is free forever, no card. Hosting starts at $5.99/mo.
The count, drawn
One call rules out exactly one place.
An agent's search tools are the ones a person types into a terminal: list a folder, grep for a string, read a file. Each one answers a yes-or-no about a single spot on the disk. To locate one file among millions with only local yes-or-no probes, you need a lot of probes: the agent runs the same four-step round roughly eighteen times. And because every call re-reads the whole transcript so far, the calls keep getting more expensive as they pile up. Here is what 71 of them look like next to one.
Same machine, same drive, same file. Seventy-one blind probes above; one indexed call below.
The compounding
Each call costs more than the one before it.
A tool call isn't billed on its own. The model re-reads the entire conversation (every earlier listing, every failed grep, every file it already opened) before it can decide what to try next. So call two carries call one; call seventy-one carries all seventy. The token bill doesn't add up, it compounds. That is how a search that should be free ends up eating ~58% of the session's tokens, walls of directory output the model reads once and forgets a turn later.
The gap between hunting for a file and knowing where it is, on the same drive. A narrower, cleaner test (one file by name, nothing else) put Claude Code at 193.5 seconds against the same indexed lookup at 85 microseconds: 2,276,000×. Measured on a Ryzen 9 9950X3D, 64 GB DDR5, NVMe, Windows 11, 4.47M files.
The agent · and the plan you pay for it
A better model. The same floor.
This wasn't a weak setup. It was Claude Code, running Anthropic's strongest model, on the top subscription. The uncomfortable part: the money buys a smarter thinker, not a faster way to find things: the tools underneath stay list, grep and read.
The agent
Claude Code
Anthropic's own coding agent, running its strongest model, the best you can point at a codebase. To find one file among 4.47M, it ran the four-step round 71 times.
The plan
Claude Max
$200 a month buys a better model and higher limits, not a faster floor. So the smartest agent still spends most of a session, and most of your usage budget, hunting instead of building.
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. The 71-call, 6m 57s run is a full task captured on video; 193.5 s is a narrower single-file-by-name test. Indexed lookups on the same drive are 85 µs for a single file (2 µs best case), 139 µs median across 20 queries, and content search averages ~8 ms. The 16 ms figure is one representative content query. See the companion write-ups on why the count climbs and where the tokens go.
It's the tools, not the model
Search was built for one open project, not a whole machine.
VS Code indexes the folder you opened. Cursor indexes the repo you're in. Both are fast, inside that one boundary. But an agent's questions don't respect folder boundaries: the answer might sit in a sibling repo that ships alongside this one, or in the 90% of the disk that was never in git: a config, a document, a log. Nothing keeps a warm, machine-wide view of all of it.
So the agent falls back to the floor (grep and list, one blind probe at a time) because nothing across the machine is kept ready between calls. Give the model a map and it makes one call; give it a flashlight and it makes seventy-one. The count is a property of the tools, not the intelligence.
The fix
One call. The other seventy are gone.
Interlinked keeps a live index of every file on the machine (names and contents) and hands it to any agent over MCP. One signed install auto-configures 19 AI clients, Claude Code among them. Once the indexed-search tool is registered, the agent stops reaching for grep: it asks where is this once and gets the exact path back: no walk, no round, no transcript to re-read. There is nothing left to compound. The index sits warm in the background at about 44 MB and stays current as you save (roughly a millisecond, under 30 ms worst case), so the answer is never stale.
Same agent · same model · same query
Without index
With Interlinked
Seventy-one blind probes replaced by a single index lookup. Same model, same machine: a different floor.
THE MODEL DIDN'T GET SMARTER. THE FLOOR GOT FASTER. THAT'S THE ONLY THING THAT CHANGED.
Common questions
The questions people ask after the count.
How many tool calls does it take Claude Code to find one file?
On a real 4.47-million-file machine, Claude Code (running Anthropic's strongest model) made 71 tool calls over 6m 57s to open a single file. Pointed at the same machine with a live index, the job is one call, 16 ms.
Why does searching burn so many tokens?
A tool call is not billed on its own: the model re-reads the entire transcript before deciding what to try next, so call 71 carries all seventy before it. That compounding is why hunting eats ~58% of a session's token budget; with an index it drops to ~0%.
Wouldn't a bigger or smarter model fix this?
No. This was already the strongest model on the top plan. list, grep and read each answer one yes-or-no about one spot on disk, so the count is a property of the tools, not the intelligence. A warm, machine-wide index turns the whole hunt into one lookup.
How fast is an indexed lookup compared with the tools I already use?
A single filename lookup is 85 µs (139 µs median), about 412,000× faster than VS Code and ~480,000× faster than Windows Search (67 s). Content search returns in ~7-9 ms where ripgrep needs 93.8 s on the same drive (up to 58,625×).
Does the index stay current, and what does it cost?
It refreshes within about 1 ms of a save, so answers are never stale, and it idles at ~44 MB, less than a browser tab. Everything local is free forever, no card. Hosting starts at $5.99/mo.
Do this today
Turn 71 calls into one.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed and the rest. No JSON editing.
Let it index. Filename search works immediately; content search fills in behind it. At rest the whole engine sits around 44 MB and updates as you save.
Scope when you can. Whole-machine when you don't know where something lives; scoped to a folder when you do. Scoped queries return in the microsecond range.
Watch the count drop. The agent trades seventy-one blind probes for one call that returns the exact path, and stops spending its token budget on directory listings.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.