Agents · measured July 2026 · 8 min
The 10x engineer was a myth. The 10x agent is real, if it can find things.
The 10x engineer was always an argument you couldn't win: a legend built on a tiny 1968 study, not a measured fact. An agent is different: it parallelizes, it never tires, a second copy costs pennies. The multiplier is real now. But we watched Claude Code look for one file for 6 minutes and 57 seconds, and no model upgrade rescues a session that spends that long at the bottom of the stack. A 10x agent can't exist above a 1x floor.
TL;DR: the short version
The “10x engineer” traces to a shaky 1968 study and has been argued over ever since: human output was never that linear.
An agent parallelizes and never tires, so a real multiplier exists, but it is capped by its slowest repeated step: retrieval.
On a 4.47M-file machine an agent spent 6m 57s and 71 tool calls finding one file; ~58% of session tokens go to hunting.
That 58% is a wall: speed up the model infinitely and the session still only gets ~1.7× faster. The floor decides.
Interlinked answers the same lookup in 85 µs, 412,000× faster than VS Code. Collapse the floor and the ceiling lifts.
The myth, honestly
“10x engineer” was always an argument. “10x agent” is closer to arithmetic.
The phrase traces to a 1968 study that timed a small group of programmers and found some finished the same task far faster than others, as much as tenfold on a couple of measures. It has been fought over ever since, because the sample was tiny, the tasks were narrow, and human output was never that clean: the person who writes ten times the code often creates ten times the cleanup, and the strongest engineers multiply the people around them more than themselves. The 10x engineer is a useful legend, not a number you can bank.
An agent breaks the analogy. It does not tire, it forks into parallel tasks, and running a second copy costs pennies instead of a second salary. Point five agents at five files and you get five edits at once: the real version of a multiplier the human legend only gestured at. So “10x agent” is not marketing; it is close to bookkeeping.
Except a multiplier is only as high as the slowest thing you do on repeat. And the slowest thing an agent does (hundreds of times an hour) is not thinking. It is finding the file. Six minutes and fifty-seven seconds for one of them is not a rounding error; it is the whole session. A 10x agent that hunts for six minutes per file is a 1x agent with a large bill. The bottleneck was never the model.
Amdahl's law, meet your agent
You can't out-model the floor. The slowest step sets the ceiling.
The retrieval floor is the speed of the slowest thing your agent repeats all day (finding files and reading them), and it quietly sets the ceiling on every other improvement. There is a fixed law for this. Speed up one part of a job and your total speedup is capped by the part you did not touch. Retrieval is the part almost nobody touches.
Where an agent session goes
WITHOUT AN INDEX
WITH THE INDEX
On the benchmark machine, about 58% of an agent session went to finding files. Feed that into the law and the ceiling is blunt: make the model infinitely fast and the whole session still only gets about 1.7× faster: that is nothing but 1 ÷ 0.58, the arithmetic of the floor, not a figure we chose. Every dollar poured into the model above that line buys almost nothing, because the model is not what you are waiting on. The only way past the ceiling is to shrink the floor itself.
Read the blue curve against the red. Same model improvement on the bottom axis; two completely different outcomes, decided entirely by the floor. Collapse retrieval from 58% toward zero and a 10×-better model finally delivers something like 10×, instead of dying at 1.6×. The chart is honest arithmetic, not our benchmark; the benchmark is the input. The levers that actually move the clock and where the tokens go both land in the same place.
The floor, measured · same machine · same file
The floor is not a metaphor. It is a number you can time.
One real file-find request on the benchmark machine, resolved to a single query. With no index the agent reached for its shell tools and ground through it; with the same query answered by a prebuilt index, the work collapsed. Same model, same drive, same request.
Even the simplest slice of that task (one file, searched by name) took the agent 193.5 s of blind walking, long enough for a coffee run; the index returns it in 85 µs (a single blink holds several thousand of them) on its own 2,276,000× faster, and the full run collapses by more than seven-million-fold. The same floor, timed against every tool that touches it:
| The searcher | The task | Time | vs the floor |
|---|---|---|---|
| Interlinked | one indexed lookup | 85 µs | the floor |
| VS Code Ctrl+P | same file, same drive | 35 s | 412,000× slower |
| Windows Search | median of 20 queries | 67 s | ~480,000× slower |
| ripgrep (what your agent runs) | one content query | 93.8 s | 58,625× on the set |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Filename look-ups are a 139 µs median across 20 queries (85 µs for a single file, 2 µs best case); the ripgrep row is one content query over the same corpus (93.8 s versus 16 ms), 58,625× faster averaged across the five-query set. Full per-tool method in the 412,000× VS Code write-up and the ripgrep comparison.
Shrink the floor
Give the agent a floor that answers instantly. Then let it be a 10x agent.
Interlinked keeps an always-fresh index of every file on the machine (names and contents, every repo, the git-ignored files a cwd grep never sees, documents included) and hands it to any agent over MCP. One signed install wires up 19 AI clients, Claude Code among them, with no JSON editing. Search was built for a human with one project open; an agent's questions don't respect folder lines, so it fell back to grepping the whole disk. The index is the layer that was missing: machine-wide, and fast enough that retrieval stops showing up in the timing.
And the multiplier compounds, because the same index carries a knowledge vault that rides along on the searches the agent already runs, with no model in the loop. On a fresh machine it found 12 of 12 repos and replayed 8,455 git events in 1.7 s into 26,958 relationship pairs, and flagged two repos that quietly share 435 identical files, unprompted. Speed finds the file; the vault knows why it matters. The whole engine sits around 44 MB at rest and the index stays under 1% of the drive.
ONE INSTALL · 19 AI CLIENTS · THE FLOOR BECOMES INSTANT.
Questions worth asking
Straight answers.
Is the 10x agent real, or just hype?
Real in a narrow, honest sense. An agent parallelizes work and never tires, so it can genuinely multiply throughput in a way a single human never could. But the multiplier is capped by the slowest thing it does on repeat: usually retrieval, finding and reading files. Fix that and the multiplier shows up; leave it and you have a 1× agent with a large bill.
Why doesn't a smarter model or a bigger plan fix it?
Amdahl's law: your total speedup is limited by the part you did not speed up. If ~58% of the session is file hunting, a faster model caps out around 1.7× no matter how good it gets: that is just 1 ÷ 0.58. The retrieval floor is the part worth fixing, and almost nobody touches it.
What exactly is the “retrieval floor”?
The speed of the slowest thing an agent repeats all day: locating the right file and reading it. On a 4.47M-file machine an agent shelled out to grep-style scans and spent 6m 57s finding one file; a prebuilt index answers the same lookup in 85 µs.
Does this replace my vector database, RAG, or model memory?
No: it is the layer underneath them. A fast, exact index of names and contents, plus a receipts-based knowledge vault, with no model in the loop. RAG guesses with embeddings; a lookup is a word, a row, a list of files. Keep your stack; give it a faster floor. More on that here.
Won't the index be stale right after I edit a file?
No. A save is searchable again in about a millisecond, under 30 ms worst case, so the index never lies about a file you just wrote. It is a live map, updated as files change, not a nightly rebuild.
Do this today
Uncap your agent.
Install once. One signed installer wires up 19 AI clients: Claude Code, Cursor, Codex, Copilot, Windsurf, Zed and the rest. No config, no keys.
Let it index. Filename search works immediately; content fills in behind it. At rest the whole engine sits around 44 MB, less than a browser tab.
Point it at a path when you can. Whole-machine when you don't know where something lives; scoped to a folder when you do. Scoped queries return in microseconds.
Stop pre-pasting file trees. Let the agent ask the index instead of grepping the disk. That is the move that takes the ~58% floor down to ~0%, and lets the multiplier show up.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.