Agents · the retrieval gap · measured July 2026
The Matrix uploaded kung fu in seconds. Your agent uploads context by grepping for six minutes.
In the film, Neo jacks in, a martial-arts program loads straight into his brain, and he opens his eyes with a line the whole internet still quotes: "I know kung fu." No training montage. Just an instant upload. Real AI agents can't do that with a skill, but the thing they actually burn their day on isn't skill, it's finding the context, and that they still do the slow way. On a real 4.47-million-file machine, one measured run to gather context for a single task made 71 tool calls and took 6 minutes 57 seconds. This is a playful metaphor with a measured ending: the instant-upload version of retrieval is real, and it answers in 16 milliseconds.
TL;DR: key takeaways
- 01Fiction skipped the montage. The Matrix showed skills loading into a mind in seconds. It never showed the boring part a real agent is stuck in: gathering the context before it can act.
- 02The slow way is measured, not hypothetical. One real Claude Code run made 71 tool calls over 6 m 57 s to locate a single file, and spent roughly 58% of the session's tokens on the hunt.
- 03The upload is retrieval, not skill. A live, always-warm index answers the same request in one call: 16 ms. That is about 7,200,000× faster end to end: a six-minute scramble against a single blink.
- 04No AI in the box. There is no model in the loop: an index and a match, offline, on your machine. It doesn't make the model smarter; it makes the context arrive instantly so the model can get to the thinking.
- 05Same drive, honest numbers. A single filename lookup runs in 85 μs across 4.47M files; the content query that takes ripgrep 93.8 s returns in 16 ms.
What the film actually showed
The dream is instant. The reality is a loop.
Give the movie its due: it was accurate about its own fiction. An operator loads a program, the skill appears with no practice in between, and later Trinity asks for a helicopter-pilot program and flies a B-212 seconds after. That is the fantasy in one image: you request a capability and it is simply there. It is a metaphor, not a spec sheet, and we are not claiming a model learns like Neo.
Here is the honest gap. An AI coding agent does not need to learn your codebase to work on it; it needs to find the right parts of it. Context gathering is everything an agent does before it can act: locating the right files, reading their contents, and recalling what was already decided. That is the layer the film fast-forwarded through, and the layer today's agents are stuck grinding in real time.
So instead of an upload, the agent runs a montage: grep the disk, read a few thousand candidate lines, narrow, grep again: a loop where each pass decides the next. It is diligent. It is also the slowest thing the agent does all day, and it never looks like the movie.
The montage vs the upload
Same task. Only how the context arrives changed.
The two ways to gather context for one task, drawn on the clock. On top, the montage: every grep returns roughly four thousand lines the agent has to read, so it loops (71 times in the run we measured) and the red run stretches across the timeline to a finish at 6:57. On the bottom, the upload: the same context is already indexed, so one ask lands in 16 milliseconds and the rest of the timeline never happens.
This is the same shape latency takes in any dependent chain: an agent can't fire its searches in parallel, because each result decides the next question. We drew that mechanism out in why one slow tool call ruins an agent run. The ≈6 s is the measured run's own average across 71 calls; individual searches ranged from milliseconds to 93.8 seconds.
One task · measured, not modeled
We watched Claude Code find one file.
That was the whole workflow: plan, search, narrow, repeat. End to end, the montage and the upload came out about 7,200,000× apart: put humanly, a six-minute, fifty-seven-second scramble against a single blink. Strip it down to one isolated lookup on the same drive and the floor is no kinder: Claude Code took 193.5 seconds where the index returned the identical answer in 85 microseconds. The model never changed between those numbers. Only how its context arrived did. We logged the full run in the Claude Code write-up.
Same machine · same drive · same lookup
The gap, in numbers you can check.
Every tool below runs the same lookup on the same drive. The times are the ones that build the montage: 35 seconds to open a file you already named, 67 seconds to answer one query (long enough to top up your coffee), and 93.8 seconds for the content search the agent leans on hardest.
| The searcher | The task | Time | vs Interlinked |
|---|---|---|---|
| Interlinked | one indexed lookup | 85 μs | the baseline |
| ripgrep (what your agent runs) | content query, same drive | 93.8 s | 58,625× on the set |
| VS Code · Ctrl+P | open a file you already named | 35 s | 412,000× |
| Windows Search | median of 20 queries | 67 s | ~480,000× |
| Claude Code · full run | grep-hunt one file, 71 calls | 6 m 57 s | ~7,200,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Interlinked single-file lookup 85 μs (139 μs median of 20 queries); the content query that takes ripgrep 93.8 s returns in 16 ms (58,625× averaged across the query set, ~7 to 9 ms typical). The Claude Code row is the measured agent run: 6 m 57 s across 71 calls. Per-tool detail in the 412,000× write-up and the ripgrep comparison.
What actually gets "uploaded"
We can't upload kung fu. We can make the context arrive as if we had.
Map the scene honestly. The operator who loads the program is the live index. "I need a pilot program" is a single query. And the skill appearing with no montage in between is the context landing in 16 milliseconds instead of seven minutes of grep. What we do not do is pour knowledge into the model's head: the model still does the thinking. We remove the montage from the one part that was pure waiting: retrieval.
The operator also remembers. Alongside the search, the same index keeps a knowledge vault: short notes and relationships that live on your files and folders, fed back to the next agent on the searches it already runs, so the machine gets a little more known every week, with no model guessing anything. Not a replacement for RAG or your model's memory: the layer under both.
The fix · give the agent the upload
Delete the montage. Keep the model.
A live, always-warm index of every file on the machine (names and contents) turns the whole retrieval loop into one call. The answer is already built and waiting instead of walked on every query, and the result is the handful of files that actually match, not a grep dump the agent has to loop through. The montage that took 6 m 57 s over 71 calls becomes an upload that returns in 16 ms.
NO MODEL IN THE LOOP: THE ENGINE IS AN INDEX AND A MATCH · EVERY ANSWER STAYS ON YOUR MACHINE, OFFLINE.
Questions people actually ask
The honest FAQ.
Can an AI agent really learn my whole codebase instantly, like Neo?
No, and nobody honest should tell you otherwise. A model doesn't upload skills into its weights the way the film shows. What can be instant is retrieval: the specific files and contents the agent needs arrive in one call instead of a 71-call, 6m57s grep hunt. The thinking still belongs to the model.
Why does my agent take so long to find the right file?
Because it searches the way a human with a terminal would: grep the disk, read a few thousand candidate lines, narrow, grep again: a serial loop where each result decides the next. On a 4.47M-file machine one measured run made 71 of those calls. A pre-built index answers the same question once, in the microsecond range.
Is Interlinked an AI model or another RAG pipeline?
Neither. There is no model in the loop: it's a live index and a match, offline, on your machine. No embeddings, no cloud, no keys. It sits underneath RAG and your model's memory rather than replacing them.
How is this different from ripgrep or VS Code search?
ripgrep and VS Code walk the filesystem on every query. Brilliant tools, but they re-do the work each time (93.8 s and 35 s in our tests). The index does the walking once and keeps the answer warm, so the same lookup returns in 85 microseconds and the same content query returns 58,625× faster.
Does the index stay current, or do I have to rebuild it?
It stays current on its own. Save a file and it's searchable in about a millisecond (under 30 ms in the worst case), so no request ever waits on a stale index. At rest the whole engine sits around 44 MB.
Do this today
Give your agent the upload.
Install once. One signed installer auto-configures 19 AI clients (Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline and the rest) over MCP. No JSON to edit, no keys.
Let it index. Filenames are searchable immediately; contents fill in behind them. At rest the engine sits around 44 MB, and the index on disk stays under 1% of the drive.
Stay fresh for free. Save a file and it's searchable in about a millisecond (under 30 ms worst case), so no hop in the agent's chain is ever waiting on a stale index.
Scope when you can. Whole-machine when you don't know where something lives; a folder when you do. Scoped queries return in microseconds either way.
Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo. Download for Windows.
Keep reading: the backbone of the LLM economy (the umbrella thesis), why one slow tool call ruins an agent run, and content search vs ripgrep.