Agents · measured July 2026 · 8 min read
Devin promised an AI software engineer. The hard part was never writing code.
In 2024, Cognition introduced Devin and described it as the “first AI software engineer.” The demo was real: it wrote code, fixed a bug, shipped a change end to end. But it quietly raised the question the whole field keeps dodging: if an AI can write the code, why isn't the job done? Because the typing was never the job.
On a real 4.47-million-file machine we measured where an agent's time actually goes, and it isn't generation. It is finding the right file, reading the right code, and remembering what it already learned. Left to its own tools, Claude Code spent 6 minutes and 57 seconds on that. With an index underneath it: 16 milliseconds. Retrieval, not generation.
TL;DR · the 60-second version
- 01
Cognition introduced Devin in 2024 and described it as the “first AI software engineer.” The demo was real, and so was the lesson underneath it: the bottleneck was never the typing.
- 02
Code generation is largely solved. Modern models write, refactor, and translate code well. What stays unsolved is navigation and memory: finding the right file, reading the right code, and recalling what was decided last time.
- 03
Measured on a 4.47-million-file machine, Claude Code spent 6 minutes 57 seconds and 71 tool calls to find one file. About 58% of the session's tokens went to hunting, not thinking.
- 04
The same lookup against a live whole-machine index took 16 milliseconds and one call, end to end roughly 7,200,000× lighter. That is retrieval, not generation, and it is a search problem, not a model one.
- 05
Interlinked Files is that index, plus a knowledge vault that remembers what was learned across every repo, keyed to the file itself. No model in the box, offline, private.
The job, honestly described
An AI software engineer's real job is mostly retrieval.
An AI software engineer is an autonomous coding agent that plans, edits, and ships changes across a real codebase with little human steering. Run one on a real machine and the same truth surfaces that every human engineer already knows: the writing is the small part. Engineers read far more code than they write: locating the one file that matters among millions, reading enough of the surrounding code to be safe, and recalling what was decided the last time they were here.
Devin's demo compressed all of that into a tidy sandbox. Your machine is not a tidy sandbox. It holds a dozen repos that ship together, plus the 90% of the disk that was never in git: configs, logs, documents, the one file with the answer. Generation is portable: it moves with the model, the same in every editor. Navigation is where reality bites, and it is the bedrock layer under every agent, the slowest, most token-expensive thing they do.
Two halves of one job
One half is solved. The other half runs the clock.
Draw the capabilities honestly and the shape of the problem appears. The left column is what the demos show (writing, refactoring, translating), and its bars are full. The right column is what actually happens for minutes at a time on a real machine, and its bars are nearly empty. The gap between the two columns is the entire opportunity.
Every number on the right is a search, not a keystroke. A smarter model makes the left column better and does nothing for the right. The right column only moves when the layer beneath the agent stops walking the disk and starts answering from an index.
One real task · measured end to end
We watched Claude Code find one file.
Six minutes and fifty-seven seconds (long enough to make a coffee) spent looking for a file the agent had already seen once. Sixteen milliseconds is a third of the time it takes to blink. Fold time, tool calls, and tokens together and that one workflow came in about 7,200,000× lighter. And ~58% of the session's tokens (more than half the bill on a $200/month plan) went to directory listings the model would forget one turn later. Not one of them wrote a line of code. We timed the full grind separately; the fix is not a smarter model: it is a faster floor.
Same machine · same drive · same queries
Every slow step is a search step.
| The step (navigation, not typing) | What the agent falls back to | Time | With the index |
|---|---|---|---|
| Locate a file by name | VS Code Ctrl+P | 35 s | 85 µs |
| Find a string across the code | ripgrep, hard query | 93.8 s | 16 ms |
| A whole session of file-hunting | Claude Code grind | 6 m 57 s · 71 calls | 16 ms · 1 call |
| Recall what was learned last time | re-derived each run | every session | instant recall |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Single-file lookups run a median 85 µs (best case 2 µs; 139 µs across 20 whole-drive queries). The ripgrep row is one hard content query timed both ways: 93.8 s walking the disk, 16 ms indexed, a 58,625× median speedup across the content set. The Claude Code row is the measured agent run, wall time and tool calls folded in. Full per-tool methodology in the ripgrep comparison and the 412,000× VS Code write-up. Notice the pattern: not one of these steps is the model writing code. Every one is the agent trying to find or remember something, and the fix for retrieval is an index, not a bigger brain.
The other unsolved half
Generation you can watch. Memory you can't.
The second half of navigation is remembering. An engineer who has been in a codebase for a year is worth more than one who arrived this morning, because they carry the map. Devin starts every task with amnesia; so does every agent, re-deriving what it learned last session, every session. The same live index that answers in milliseconds also carries a knowledge vault: relationships it derives by itself from your machine's own history: which files change together, which repos share code, what a folder actually is. Keyed to the file's identity in the operating system, so it survives renames, spans every repo, and belongs to no vendor. That is why your agent's memory dies on rename today, and doesn't have to.
SPEED FINDS THE FILE. MEMORY KNOWS WHY IT MATTERS. AN AI ENGINEER NEEDS BOTH.
Questions people ask
The honest FAQ.
Is this affiliated with Cognition or Devin?
No: no affiliation, no endorsement, no sponsorship. Cognition publicly introduced Devin as the “first AI software engineer,” and this article takes that framing seriously to make a narrower point: writing code was never the hard part of software engineering. The famous product is the doorway, not a partner.
Did Devin fail?
No. Devin proved that code generation works: an agent really can plan, edit, and ship a change end to end. The useful takeaway is that generation is the solved half. Navigation and memory are the unsolved half, and those are retrieval problems, not model problems.
What does “retrieval, not generation” actually mean?
Retrieval is the step of locating and recalling the right context before any code is written: the right file among millions, the right surrounding code, and what was decided last session. On a real machine that is where the minutes and the tokens go, which is why agents need better retrieval, not a bigger brain.
Is Interlinked Files an AI, or a Devin competitor?
Neither. There is no model inside it. It is the retrieval layer underneath any agent (Devin, Claude Code, Cursor, Copilot), handing them instant whole-machine search and a knowledge vault through one MCP server. It makes those agents faster; it does not replace them.
How much faster is it, really, and what does it cost?
On the benchmark machine, one file among 4.47M returns in about 85 microseconds (139 µs median across 20 queries) versus 35 seconds in VS Code and about 67 in Windows Search; a content query that took ripgrep 93.8 seconds returned in 16 milliseconds. The index never leaves your machine, and nothing is uploaded unless you publish a project or a link. Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo.
Do this today
Give your agent the part that's actually hard.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline and the rest. No JSON editing, no keys.
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) and the index is under 1% of the drive.
Point your agent at it. Now the retrieval half is a single call that returns in milliseconds instead of a 71-call archaeology dig. Whole-machine when you don't know where something lives; scoped to a folder when you do.
Let the vault grow. Day one it reads your git history. Every week after, it knows your machine better: automatically, keyed to the files themselves, shared by every agent.
The demos showed you the half that was already easy. Everything local is free, forever: the app, whole-machine search, MCP. Hosting starts at $5.99/mo. Download for Windows and hand your agent the half the demos never showed.