Explainers · measured July 2026

Agentic search is a loop, not a query.

When you search, you type once and scan the results. When an AI coding agent searches, it does something different: it runs a query, reads a few of the hits, decides they are not quite right, writes a sharper query, and runs it again, over and over until it has the context to act. That search-read-refine loop is what makes agents feel capable. It is also what makes them slow and expensive, because every turn of the loop is another tool call and another pile of tokens. Here is the loop, drawn on a real 4.47-million-file machine, and the one thing that decides whether it costs minutes or milliseconds.

The loop, drawn

Search. Read. Refine. Then do it again.

A one-shot search returns a list and stops. An agent's search is a cycle: each lap it searches the disk, reads the hits into its context, and (if that was not enough to answer) refines the query and goes around again. It exits only when a read is finally enough. Follow the arrows. The two stages tinted red are where the bill is run up: the search walks the disk (that is where the seconds go), and the read pours results into the context window (that is where the tokens go).

Every lap pays both taxes (wall-clock on the search, tokens on the read), and the loop can run dozens of times before it exits. The counter in the middle is not a worst case; it is a measured run: 71 laps to locate one file. Shrink the cost of one lap, or the number of laps, and the whole loop gets cheaper.

Why the loop gets expensive

One question. Seventy-one searches.

The loop is powerful precisely because it is iterative: the agent corrects itself, narrows in, recovers from a bad first guess. But iteration has a price, and the price is paid per lap. We watched Claude Code find a single file on the benchmark machine and counted:

Each of those 71 searches walked the disk and pushed its results back into the context window, where the model re-reads them on every turn that follows. The loop did not fail. It found the file. It just paid the search-and-read tax seventy-one times to get there. And none of this is the agent's fault, nor ripgrep's: the loop is the right strategy, and ripgrep is excellent at reading a disk quickly. The trouble is that the search primitive underneath the loop was never meant to be called seventy-one times to answer one question.

Same machine · same drive · same file

One turn of the loop, and the whole loop.

Underneath the loop sits a single search primitive. In Claude Code, that primitive is ripgrep, a fast, well-built tool that reads the filesystem on every call. One turn of the loop is one ripgrep run; the whole loop is that, times the number of laps. Measured on the same drive, the gap between one turn and the whole loop is exactly the multiplier from the diagram:

Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. * 58,625× is the average across a five-query content set; on the single query shown, 93.8 s collapses to 16 ms from the warm index. Interlinked also returns a single file by name in 85 μs (139 μs median of 20 queries, best case 2 μs). Per-tool detail in the ripgrep comparison and the anatomy of a tool call.

The multiplier

A loop is only as fast as one turn of it.

Here is the uncomfortable arithmetic of agentic search: total cost is the cost of one search times the number of searches. That makes the search primitive the single most leveraged thing in the system. If one turn takes seconds, a 71-lap loop takes minutes, and the model can do nothing but wait on the disk. If one turn takes microseconds, the same loop finishes before you can blink. A faster primitive does something subtler, too: when a search returns the three files that matter instead of three thousand lines to sift, the agent needs fewer laps to be sure, so both terms of the product shrink at once.

Same loop, same agent, same question. The only thing that changed between the two bars is how long one search takes, and that one change is the difference between a 6-minute-57-second hunt and a 16-millisecond answer.

NO MODEL IN THE LOOP: THE SEARCH IS AN INDEX AND A MATCH · EVERY ANSWER STAYS ON YOUR MACHINE.

Do this today

Give the loop a faster floor.

Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. No AI, no keys, no metered lookups. The index never leaves the machine. Download for Windows.