Explainers · measured July 2026
What is an AI coding agent?
A large language model wired into a loop. You give it a goal ("add rate limiting to the API") and instead of just printing an answer, it plans the work, calls tools to read your files and run commands, edits the code, checks the result, and repeats until the goal is met. Claude Code and Cursor are the two most-used examples; GitHub Copilot grew from autocomplete into one. The loop is what makes it an agent. It is also where the time goes, and almost none of it goes where you would think.
The whole idea, in one picture
One instruction in. A loop until it's done.
Read it left to right for the happy path: goal, plan, tool calls, edit, done. The curved arrow underneath is the part that matters: when the work isn't finished, the agent doesn't stop, it plans the next step and goes around again. A single real task can circle this loop dozens of times, and the accent stage (the tool calls that touch your disk) is the one it repeats most.
The model never touches your machine directly. It emits a request (read this file, search for that string, run this command) and the harness around it (Claude Code, Cursor) carries it out and hands the result back. Everything the agent knows about your code, it learned through a tool call.
Anatomy · three parts
Autocomplete suggests. An agent acts.
GitHub Copilot started as autocomplete: it suggested the next line and waited for you to accept it. An agent closes the loop: from one instruction it decides, acts, and checks its own work, over and over, with little or no input from you. Strip away the branding and every coding agent is the same three parts.
Claude, GPT-class models. Reads the situation and picks the next move. Fast and capable. It is the part your monthly subscription pays for.
Claude Code, Cursor, Copilot, Windsurf, Cline. Runs the loop, dispatches each tool call, and applies the edits the model asks for.
Read a file, search the codebase, run a command, write an edit. This is the only part that leaves the model and hits your disk.
Two of the three got dramatically better over the last two years. Models double in capability; harnesses ship new features weekly. The third part (the tools that reach into your files) is running on the same primitives a laptop used in 2006. That is the seam this whole series pulls on.
The hidden bottleneck
Every loop begins by finding the code.
Here is the part the demos skip. The model's reasoning is quick. The edit itself is usually a few lines. What dominates each trip around the loop is the step before both: locating and reading the right files. And the tools an agent reaches for to do that were built to walk the whole disk on every query.
The model's steps are quick and cheap. The stall is the disk hop in the middle, and it repeats every single iteration. On a 4.47-million-file machine, a single content search with the tool Claude Code runs took 93.8 seconds.
The two anchors take different roads to the same place.
Claude Code shells out to grep and glob: it walks the filesystem on every search. Cursor keeps a semantic index of the repo you opened, which is genuinely useful inside that folder. But an agent's questions rarely stay inside one folder: the moment the query leaves the workspace (another repo, a config, a git-ignored file, the PDF with the answer) Cursor falls back to the same disk walk. Both land on the same slow step.
| The agent | How it finds context | Time · 4.47M files | vs Interlinked |
|---|---|---|---|
| Interlinked | one indexed lookup, whole machine | 85 μs | 1× |
| Claude Code (Grep / Glob) | shells out, walks the disk each query | 93.8 s | 58,625× * |
| Cursor | repo index inside the folder; disk walk outside it | 35 s † | 412,000× |
| Windows Search | full-drive search, median of 20 | 67 s | ~480,000× |
| Claude Code · full run | 71 tool calls to find one file | 6 m 57 s | ~7,200,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Interlinked on the same tasks: 85 μs by name, 139 μs median of 20 queries, 16 ms on the 93.8 s content query. * 58,625× is the average across the five-query content set; on the single query shown, 93.8 s collapses to 16 ms. † Cursor is built on VS Code; its file-open and outside-workspace search use the same machinery. Per-tool detail in the ripgrep comparison and the 412,000× write-up.
One real session, timed
We watched an agent find one file.
Tokens spent finding files are tokens not spent solving your problem. In one measured Claude Code session, roughly 58% of the tokens went to file hunting: the model reading directory listings it forgets a turn later. A single forgotten-file lookup took 193.5 seconds on its own: 2,276,000× the 85 μs an indexed lookup needs. The loop is not slow because the model is slow. It is slow because every iteration re-walks the disk.
Fix the third part
One warm index. The loop stops waiting.
You cannot make the agentic loop go away: it is the point. But you can make its slowest stage instant. Pre-index every file on the machine once, keep it warm in the background, and the tool call stops walking the disk: it answers from memory. The seconds collapse, the loop stops stalling, and because the result is the handful of files that actually match instead of a page of raw output, the token bill collapses too.
The result can carry more than paths, too. On a fresh machine the index seeded 26,958 relationships from 8,455 git events across all 12 repos in 1.7 seconds, so an answer can arrive already knowing which files change together and what a past agent noted about them. That is future trips around the loop the agent never has to take.
NO MODEL IN THE LOOP: THE ENGINE IS AN INDEX AND A HASHMAP · EVERY ANSWER STAYS ON YOUR MACHINE.
Do this today
Give your agent a shortcut to the disk.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Windsurf, Cline, Zed, Codex 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, and the index on disk stays under 1% of the drive (~24 GB on a 4 TB machine).
Stay fresh for free. Save a file and it is searchable in about a millisecond: under 30 ms worst case. The loop never has to wait on a stale index.
Scope when you can. Whole-machine when you do not know where something lives; scoped to a folder when you do. Scoped queries return in microseconds.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.