Guides · Local MCP · measured July 2026
Give your AI the whole machine. Without giving it away.
An agent is only as useful as what it can see. Point it at one folder and it's blind to the other dozen repos, the config that actually breaks the build, the PDF with the answer. So you want to hand it your whole machine. The catch is the obvious one: giving an AI access to your files usually means uploading them. This is the guide to doing it the other way: where the agent gets everything, and your bytes never leave the disk.
TL;DR · Key takeaways
An agent can't touch your disk: it calls a local tool over MCP. The whole security question is where that tool keeps its index: on your machine, or uploaded to a vendor cloud.
Cloud indexers copy your files off the machine. Cursor's codebase index and Glean upload your content to index it; a local index answers the same questions with 0 bytes sent, fully offline.
Local is faster, not just safer. On a 4.47M-file machine a filename lookup returns in 85µs (412,000× faster than VS Code) and content search lands in ~7 to 9 ms, where ripgrep took 93.8 s.
For agents the payoff compounds. A file hunt that cost Claude Code 6m 57s across 71 tool calls drops to 16 ms and a single call, cutting file-search token burn from ~58% of a session to ~0%.
One install, nothing to configure. A signed installer wires up 19 AI clients and runs a background index: idle ~44 MB, a saved file searchable again in ~1 ms. Everything is free forever, no card. Hosting starts at $5.99/mo.
First, the mechanism
An agent can't read your disk. It has to ask.
A language model has no filesystem. To touch a file it calls a tool: a small program on your machine it's allowed to run. The open standard for wiring those tools into agents is MCP, the Model Context Protocol: a local server advertises a handful of tools (“search files,” “read this path”), and any MCP-capable agent (Claude Code, Cursor, Codex and the rest) can call them. The agent asks, the server answers.
Two things decide whether this is safe: where the server runs, and where it keeps its index. Keep both on your machine and nothing is ever exposed. Push either into a cloud and a copy of your files goes with it. That single choice is the whole security question, and it's the next picture.
The one decision that matters
Same files. Two very different boundaries.
Every tool that gives an AI access to your content makes one choice: index it on your machine, or upload it to be indexed in a cloud. Both can answer the agent's questions. Only one keeps your code, your documents, and your secrets on hardware you own.
How it's done today
The famous answers upload first.
Two of the best-known ways to give AI access to your work both chose the cloud, deliberately, for real benefits like cross-device sync and team sharing. Cursor builds its codebase index by sending your code to its servers to be turned into embeddings; the index lives in Cursor's cloud, not on your disk. Glean is enterprise search whose entire model is to ingest your company's content (documents, tickets, chats) into Glean's cloud and index it there. Both are legitimate tools. Both require your content to leave the machine.
For a developer who just wants an agent to find things on their own laptop, that's a large tradeoff for benefits they may never use. Here is where the bytes actually go:
| The approach | What leaves your machine | Where the index lives | Offline |
|---|---|---|---|
| Interlinked Files | Nothing | On your disk | Yes |
| Cursor · codebase indexing | Your code, to be embedded | Cursor’s cloud | No |
| Glean · enterprise search | Your docs, chats, tickets | Glean’s cloud | No |
| ripgrep / grep · local | Nothing | Nowhere: re-walks each query | Yes |
Based on each product's public documentation, July 2026. Cursor offers a privacy mode that avoids retaining plaintext code, but the index is still built in its cloud. ripgrep and grep are local and private, but they keep no index and re-scan the drive on every query, which is why the same content search that Interlinked answers in 16 ms took ripgrep 93.8 s on this machine. Local, private, and fast is the combination that's hard to get.
The local alternative
Everything the agent needs. Nothing off the disk.
Interlinked Files keeps the entire pattern on your machine. A background service maintains a prebuilt, always-fresh index of every file: names and contents, across every repo, including the git-ignored files a folder-scoped tool never sees. A file you save is searchable again in about a millisecond. Your agents reach all of it through one local MCP server. There's no account, no upload, and no cloud to breach, because there's nothing to send. It's an index and a lookup, not embeddings that need a GPU somewhere else, so it has no reason to leave your disk.
LOCAL BY DEFAULT: YOUR FILES NEVER TOUCH A SERVER YOU DON'T OWN.
Do this today
Wire it up in one install.
Install once. One signed installer for Windows auto-configures 19 AI clients and starts the local index. No JSON to edit, no keys to paste.
Let it index, locally. Filename search works immediately; content search fills in behind it. Nothing is transmitted; the index is written to your own disk.
Your agent just calls the tools. The model decides when to search by name or by content and gets a precise result list back in the microsecond-to-millisecond range.
Your files stay put. Search runs offline, no account needed, and no file names, paths or contents are ever sent. Pull the network cable and it still answers, because the index was never anywhere else.
And the safe option is the fast one
You don't trade privacy for speed: you get both. On a 4.47-million-file machine (Ryzen 9 9950X3D, 64 GB DDR5, NVMe, Windows 11), a single-file lookup returns in 85µs, 412,000× faster than VS Code searching the same drive. Content queries land in ~7 to 9 ms. The upload-first tools are slower and they take a copy of your files. Local keeps the copy and wins the clock.
FAQ · Common questions
Questions, answered.
Does my code or my files ever get uploaded?
No. The index is built and stored on your own disk, and every query and answer stays between the agent and that local index. Pull the network cable and it still answers: there is nothing in a cloud to send.
How is this different from Cursor’s codebase indexing or Glean?
Those build their index in a vendor cloud, so your content has to leave the machine to be indexed. Interlinked keeps the index local (the same questions get answered with 0 bytes uploaded) and it covers your whole machine and every repo, not a single project.
Isn’t a local index slower than a cloud service?
It is the opposite. On a 4.47M-file machine (Ryzen 9 9950X3D) a filename lookup returns in 85µs (412,000× faster than VS Code) and content search lands in ~7 to 9 ms, where ripgrep took 93.8 s on the same drive.
Which AI agents can use it?
One install auto-configures 19 MCP clients (Claude Code, Cursor, Codex, Cline, Windsurf, Zed and more) with no JSON to edit. Any MCP-capable agent calls the same local tools.
What does it cost?
Everything (whole-machine file and content search plus agent access over the local MCP server) is free forever, no card. Hosting starts at $5.99/mo.
Get it
Give your agent the machine. Keep the machine yours.
Everything local is free forever: the complete whole-machine file and content search you can use yourself, offline, plus agent access over the local MCP server every client shares. No card, no trial, no device limits.
Hosting your projects is the only paid product, starting at $5.99/mo. The tool itself costs nothing: no keys, no per-query fees, no cloud.
Download for Windows →Nothing you index is ever uploaded. The index is yours, on your disk, and it disappears when you uninstall.