Explainers · Opinion · July 2026
For a decade, the answer was always the cloud. For AI agents, 2026 is the year it comes home.
Three things are true at once this year: nearly every developer now runs at least one AI agent, those agents want to read everything you have, and no network round-trip can keep up with a lookup that never leaves the machine. Put together, they all point one way: the infrastructure an agent needs to find files, search contents, and remember what matters belongs on the machine the agent already runs on. This is the case for that shift, and the numbers behind it, measured on a real 4.47-million-file machine.
The shift, drawn
The agent already came home. Now its infrastructure follows.
Here is the whole argument in one picture. Claude Code, Cursor, Copilot: the agents already run on your machine. But the two pieces of infrastructure they lean on hardest, file search and memory, grew up in the cloud, so every query had to leave the building and come back. The move that defines 2026 is those pieces dropping down to sit next to the agent, on the machine, offline, resolved in microseconds.
The tell is where the line crosses the boundary. Cloud infrastructure can be brilliantly built and still lose a race it has to leave the machine to run. Local-first is not a smaller cloud: it is a shorter path.
Why now, and not two years ago
Each force was survivable alone. They arrived together.
None of these is new by itself. What makes 2026 the inflection is that all three crossed their thresholds in the same window and point at the same answer.
When one agent was a novelty, a slow file search was a nuisance. Now a single install wires up 19 AI clients, and every one of them pays the search tax on every session. A cost you pay once is a footnote; a cost you pay thousands of times is architecture.
An agent is only useful if it can see your work: code, configs, documents, the 90% of the disk that was never in git. The more it needs to see, the heavier the cost of shipping a copy to someone else’s server. Keeping the index on the machine turns that liability into a non-event: nothing leaves.
A network round-trip is a floor you cannot engineer past. The same content query took 93.8 s on ripgrep and 16 ms on a local index, and even a perfect cloud still has to leave the building. Speed here is a consequence of where, not how clever.
The famous anchor, and the gap it left
You used to have to choose two of these.
Glean proved “search as infrastructure” is a category worth a company: one box that reaches across all of an organization’s cloud apps and hands a person (or their assistant) the right document. But its whole model is to ingest your content into Glean’s cloud and index it there. That’s the right call for a thousand people sharing one corpus; it is a heavy one for a single developer who just wants their agent to find things on their own disk.
The local tools made the opposite trade. grep, ripgrep and find never leave the machine, but they keep no index, so they re-scan the disk on every query. Windows Search keeps a local index, but it was built for a person double-clicking, not an agent, and it answers in seconds. For years you could have local, or indexed, or machine-wide. Rarely all three, and never for an agent. Here is the gap, in one grid:
| The approach | Where it runs | Keeps an index | Machine-wide | Built for |
|---|---|---|---|---|
| Glean | A vendor cloud | Yes, in their cloud | No, company apps | People, in a browser |
| grep / ripgrep / find | Your machine | No, re-scans each query | Any path you point it at | One human, one command |
| Windows Search | Your machine | Yes, local | The drive | Desktop users (seconds) |
| Interlinked Files | Your machine | Yes, always fresh | Every file, every repo | Any agent, over MCP |
Descriptions reflect each tool’s own public documentation of where it runs and what it indexes. Glean is cloud-hosted enterprise search; grep, ripgrep and find are local but keep no index and re-walk the drive each query (documented behavior); Windows Search maintains a local index but is built for desktop users. The row that didn’t exist until now is the bottom one: local and indexed and machine-wide and built for agents.
The shift, completed
The bottom row, measured on the machine below.
Interlinked Files is that missing row. A background service keeps a prebuilt, always-fresh index of every file on the machine (names and contents, across every repo, including the git-ignored files a folder-scoped tool never sees) and every agent reaches all of it through one local server. No account, no upload, and no model anywhere in the loop. The answer is already computed when the agent asks:
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Filename figures are medians: 139 µs across 20 queries, 85 µs single-file. Content queries run ~7 to 9 ms typical, 16 ms for an exact phrase. Same machine, same drive, same queries as the VS Code write-up and the ripgrep comparison.
AND IT REMEMBERS: DAY ONE, 12/12 REPOS WEBBED · 26,958 RELATIONSHIP PAIRS REPLAYED FROM 8,455 GIT EVENTS IN 1.7 S · NO MODEL, ALL RECEIPTS.
The call
The cloud isn’t going anywhere. The per-developer agent’s foundation is coming local.
This is not an argument against the cloud: team-scale sync, shared corpora and enterprise search will live there for good reasons. It is a claim about where the bedrock under a single developer’s agent belongs: on the machine, private by construction, instant because it never travels, and machine-wide because an agent’s questions don’t respect folder boundaries. In 2026 all three forces finally make that the obvious build, not the brave one.
You can stop reading about the shift and just install it. Companion pieces: the case for local-first tools and the layers of the local AI stack.
Install once. One signed installer configures 19 AI clients (Claude Code, Cursor, Codex, Windsurf, Zed and the rest) and starts the background index. No JSON editing.
Let it stay warm. Filename search works immediately; content fills in behind it. At rest the whole engine sits around 44 MB, and the index on disk stays under 1% of the drive.
Scope when you know, go wide when you don't. A folder you know returns in microseconds; the whole machine when you don't know where something lives: every repo, plus the files that were never in git.
Let it remember. Day one it webs your repos from their own git history. Every week after, it knows your machine better, automatically, with no model in the loop.
Everything local, the full whole-machine file and content search plus agent access, is free forever, no card required, on all your devices. No keys, no per-query fees, no cloud round trip in a search. Hosting your projects starts at $5.99/mo.
Download for Windows →Nothing you index is ever uploaded. The index is yours, on your disk, and it disappears when you uninstall.