Comparisons · measured July 2026
One company made Windows search fast for AI agents. It was not Microsoft.
NTFS shipped in 1993, a genuinely good filesystem that still sits under every Windows PC. More than thirty years later, the search built on top of it takes about 67 seconds (median) to surface one file on a real 4.47-million-file drive. That is not a story about bad engineers. It is a story about what search was built for: a person typing one query, not an agent making hundreds a minute. The same lookup, on the same drive, through a warm whole-drive index comes back in 139 microseconds, and gets handed to any AI agent on the machine. Respect to Microsoft. The record is still the record.
Thirty-three years in one picture
The filesystem got old. The way it's searched barely moved.
Read it left to right. Above the line is what the operating systems did; the band under the line is the one thing that never changed: a search that indexes a slice of the disk and walks the rest when it misses. On a small drive that walk was quick. On 4.47 million files it is 67 seconds. At the far right is today: the bar is still there, and the dot beside it is the same query answered in 139 microseconds.
Apple is on the timeline for a reason. In 2005 macOS started indexing the whole startup volume by default, which is why Mac users never learned to expect a wait. Spotlight is proof that whole-volume coverage is normal and shippable. It just never crossed to Windows, and it was built for a person at a keyboard, not an agent on a deadline. The gap on the right isn't a Microsoft failure. It's an unoccupied niche: the whole Windows drive, indexed, fast enough for a machine, not just a human.
Why it stayed slow, fairly
Three honest reasons. None of them is “they did it wrong.”
Search built for the era it was born in.
It indexes a subset, by design. The built-in index covers your profile folders, the Start menu, mail (the places a person keeps things). Ask for a file outside that slice and it falls back to walking the filesystem, which scales with the size of the disk, not the difficulty of the question. In 2006 that walk was over in a blink. On 4.47M files it is where the 67 seconds goes.
It was built for a human, not a robot. One person types one query and waits half a second, a completely reasonable trade. An AI agent makes hundreds of lookups a minute, and the latency that is invisible to a person sits directly on the agent's critical path. Nobody designed for a searcher that never gets tired of asking.
The job simply didn't exist yet. When Windows Search shipped, “search” meant a box in the Start menu. Agents that shell out to grep on every question weren't a use case. They weren't anything. This is a mismatch of era, not of engineering. Even Apple's whole-volume Spotlight was built for a person, and stayed on macOS.
So the whole-drive-for-agents niche sat empty. The same cliff catches everyone without whole-drive coverage: VS Code's picker outside its workspace (412,000× slower on the same lookup), the command line, an agent shelling out to grep. A partial index is the same as no index for any file that falls outside it.
Same machine · same drive · same file
The record, line by line.
Every row below is the same 4.47-million-file drive. The filename rows are compared against a warm indexed lookup (85 µs single file, 139 µs median of 20); the ripgrep row is a content query compared against the same query answered in 16 ms; the Claude Code row is the full measured agent run.
| The searcher | The task | Time | vs Interlinked |
|---|---|---|---|
| Interlinked | one warm indexed lookup | 85 µs | baseline |
| VS Code · Ctrl+P | same file, same drive | 35 s | 412,000× |
| Windows Search | median of 20, file outside the default index | 67 s | ~480,000× |
| ripgrep (an agent's fallback) | content query over the same corpus | 93.8 s | 58,625× |
| Claude Code (no index) | the full agent run to one file | 6 m 57 s | ~7,200,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. The Windows Search figure is a median for a file that lives outside the default indexed folders; the ripgrep proof line is 93.8 s → 16 ms on the identical query. Deeper per-tool write-ups: the 412,000× VS Code comparison, the ripgrep content benchmark, and the full Windows Search head-to-head.
The half of the title that matters most
“Fast” is the boast. “For AI agents” is the point.
A person feels 67 seconds once and shrugs. An agent pays it on every question. We watched Claude Code find one file the old way and the indexed way on the same machine. The difference isn't only wall time: it's where the tokens go.
That is roughly a 7,200,000× difference on the run, and the tokens the agent used to spend grepping directory listings it would forget a turn later drop toward zero. More on why one slow lookup poisons a whole session in the backbone of the LLM economy.
What actually closed the gap
One warm index of the whole drive. Handed to every agent.
There is no trick in the title. Interlinked keeps a live index of every file on the machine (names and contents) and stays current as files change, so nothing ever falls back to a walk. A filename lookup returns in about 85 microseconds. Content search across the whole drive lands the query that takes ripgrep 93.8 seconds in 16 milliseconds. Save a file and it's searchable roughly a millisecond later. And it does all of it quietly (about 44 MB at rest, an index that stays under 1% of the drive), then exposes the same warm index to any AI client that speaks MCP. One install auto-configures 19 of them (Claude Code, Cursor, Copilot, Codex, Cline, Continue and more).
And the index doesn't just find files: it remembers how they connect. On day one, on a fresh machine, it read 8,455 git events across all 12 of its repos in 1.7 seconds, built 26,958 relationship pairs, and (unprompted) flagged two local repos that share 435 identical files. Keyed to each file's OS identity, so it survives renames and belongs to no vendor. That's the part your agent's memory loses on the first rename.
Do this today
Give the search on your PC nothing left to walk.
Install once. One signed installer builds the whole-drive index and auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline and the rest. No indexing options to tune, no JSON to edit.
Let it cover everything. Filename search works immediately; content search fills in behind it. Because the index covers the whole drive, no query ever falls back to a walk: the exact thing that makes Windows Search slow simply can't happen.
Point your agent at it. Type in the app for yourself, or let Claude Code, Cursor and Codex query the same warm index over MCP. One index on the machine, every searcher on it, and the tokens that used to go to hunting go back to thinking.
Let the vault grow. Day one it knows your git history and which repos ship together. Every week after, it knows your machine better: automatically, on-device, no model in the loop.
Everything local is free forever.
The desktop app and agent access (the same index exposed to every AI client over MCP): free forever, no card. Hosting your projects starts at $5.99/mo. Download for Windows.