Explainers · measured July 2026
Your AI can't see your code. It reads it through a keyhole.
An AI coding agent doesn't open your project the way you do. It can't glance at the file tree, can't skim a folder, can't remember where anything lives. Between the model and your disk sits a narrow channel of tool calls: search something, read something, reason, repeat. On a real 4.47-million-file machine we measured what that loop costs, hop by hop, and where it quietly falls apart.
TL;DR
Key takeaways
An AI coding agent can't see your code. It perceives it through a narrow loop of search and read tool calls, and every pass walks the disk and fills the context window.
That loop is the tax: watching Claude Code find one file took 6m 57s and 71 tool calls, burning ~58% of the session's tokens on the hunt.
A warm, whole-machine index collapses it to a single hop: the same file in 16 ms and one call (~0% of tokens), about 7,200,000× faster.
Single-file lookups return in ~85 µs (139 µs median across 4.47M files), 412,000× faster than VS Code Ctrl+P and ~480,000× than Windows Search; content search runs ~7 to 9 ms where ripgrep takes 93.8 s.
It stays out of the way: ~44 MB idle, ~1 ms edit-to-searchable. Everything local is free forever, no card. Hosting starts at $5.99/mo.
The perception loop
Search. Read. Reason. Repeat until it gets lucky.
Every question an agent has about your code becomes the same four-step cycle. The catch is that the model is blind between the steps: it knows only what the last tool call pasted into its context. So it searches again, reads again, reasons again, and the context window fills with the debris of the hunt. A warm index doesn't make the loop faster. It removes it.
One real task, hop by hop
We watched Claude Code find one file.
Each pass of the loop is a full round trip: the agent spawns a process, the shell walks the disk, and the output (often hundreds of candidate paths) is appended to the conversation, where it is re-read on every turn that follows. The whole task took six minutes and fifty-seven seconds and seventy-one tool calls; through a warm index the same file comes back in a single sixteen-millisecond call, and the search simply stops being the expensive part. Tokens spent grepping are tokens not spent thinking, and the fix is not a bigger model, it is a faster floor.
The two anchors
Claude Code and Cursor read code two different ways, and both hit a wall.
Claude Code reaches the whole machine, but with no index of its own: every search shells out to grep, find, or ripgrep and walks the disk. Cursor does the opposite: it builds an index of the repository you have open, so in-repo lookups are quick, but the dozen other repos on your machine and the ninety percent of the disk that was never in the project stay invisible. One trades speed for reach. The other trades reach for speed.
Position is illustrative; the times behind it are measured. Every tool on the chart lives along the same diagonal: you can be fast, or you can be whole-machine, but not both. The top-right quadrant is empty.
Same machine · same drive · same queries
The same lookup, everywhere it happens today.
| The searcher | The task | Time | vs Interlinked |
|---|---|---|---|
| Interlinked | one indexed lookup | 85 µs | baseline |
| Claude Code (no index) | shells out to grep and find | 3 m 13 s | 2,276,000× |
| Cursor | machine-wide, outside the open repo | out of scope | n/a |
| VS Code Ctrl+P | same file, same drive | 35 s | 412,000× |
| Windows Search | median of 20 queries | 67 s | ~480,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Single-file lookups median 139 µs across 20 queries (85 µs typical, 2 µs best case); the Claude Code row is a measured agent run, its shell tools walking the disk on every query. Cursor's index covers the repository you have open, so a machine-wide lookup falls outside its scope entirely. The engine behind these figures was re-validated in a crash-free run of roughly 1,500 queries: zero errors, correct ranking.
The fix is a warm index
Ask once. Get the exact file back.
Interlinked keeps the whole machine (every repo, every document, the git-ignored files a project-scoped search never sees) pre-indexed and sitting warm in the background. The agent calls one tool and gets a precise answer instead of a wall of candidate paths. No process to spawn, no disk to walk, no context window filled with search debris. The read-search-reason loop stops looping. A content query that takes ripgrep 93.8 seconds across this corpus comes back from the warm index in 16 milliseconds: the same query, the same drive.
And the file it finds already knows things.
The same index carries a knowledge vault the agent reads for free on the searches it already runs: short notes any agent can leave on a file or folder, and relationships derived from your machine's own history: which files change together, which repos ship as a set. No model, no embeddings, no guess, just receipts you can check.
SAME MACHINE-WIDE REACH AS THE SHELL. THE SPEED OF AN OPEN REPO. THE TRADEOFF, GONE.
Common questions
Questions, answered.
Why can't my AI agent just read my whole codebase directly?
Models never touch your disk. They perceive code only through tool calls that search and read a few files at a time, and everything they read stays in a limited context window. Without a fast index, every question means walking the disk again and refilling that window with search debris.
How much faster is a warm index than what my agent does now?
On a 4.47-million-file machine, one file comes back in about 85 µs (139 µs median), 412,000× faster than VS Code's Ctrl+P and ~480,000× than Windows Search (67 s). A real Claude Code run that spent 6m 57s and 71 tool calls to find one file collapses to a single 16 ms call.
Does it search inside file contents, or just names?
Both. Content search across every code file runs in ~7 to 9 ms, where ripgrep takes 93.8 s on the same corpus: the warm index answers the same query in 16 ms.
Will it slow down my machine or serve stale files?
No. The whole engine idles at ~44 MB (less than a browser tab) and a file you save is searchable in about 1 ms, so the agent never reasons over an out-of-date copy.
What does it cost, and does my code leave the machine?
Your code stays where it is: there's no LLM, no cloud, no embeddings, the index never leaves your machine, and nothing is uploaded unless you publish a project or a link. Everything local is free forever, no card. Hosting starts at $5.99/mo.
Do this today
Give the loop somewhere fast to land.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Codex, Windsurf, Cline 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, less than a browser tab.
Scope when you can. Whole-machine when you don't know where something lives; a folder when you do. Scoped queries return in the microsecond range.
It stays fresh. Save a file and it's searchable in about a millisecond, so the agent never reasons over a stale copy.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.