85 microseconds.
Faster than physics.
Numbers like 85 µs are easy to type and impossible to feel. Below human perception by three orders of magnitude. This is a translation into things you can picture.
TL;DR
The whole argument in five lines.
- 01A single file lookup returns in 85 µs (85 millionths of a second) across 4.47M files on one thread, with no server and no cache. Three orders of magnitude below anything a person can perceive.
- 02Finding a file is 412,000x faster than VS Code and ~480,000x faster than Windows Search, which takes a full 67 s to sweep the same drive.
- 03Searching inside files runs in ~7-9 ms; the same job takes ripgrep 93.8 s (up to 58,625x slower) and a warm query still lands in just 16 ms.
- 04For an AI agent the win compounds: one measured task fell from 6m57s across 71 tool calls to 16 ms in a single call (~7,200,000x), and the tokens spent hunting for files dropped from ~58% to ~0%.
- 05It stays out of the way (about 44 MB of memory at idle, index freshness within ~1 ms of a change) and everything local is free forever.
Best case
Light travels 4.2 km in this time
Tree walk (typical)
7,000x slower than our worst case
Eleven ways of seeing 85 microseconds
Things that take longer than one of our queries.
| Phenomenon | Duration / Distance | vs. Interlinked Files |
|---|---|---|
| Light travels (1 µs) | 300 m | Three football pitches |
| Light travels (85 µs) | 25.5 km | Manhattan to Brooklyn and back. Twice. |
| Light travels (14 µs, best case) | 4.2 km | About a mile and a third |
| DDR5 memory access | ~3 ns | 85 µs = 28,000 of these |
| L1 cache hit | ~1 ns | 85 µs = 85,000 of these |
| USB keyboard poll (USB 2.0) | 1,000 µs | 12 queries per keystroke |
| 60 fps display frame | 16,667 µs | 196 queries per frame |
| Network round trip (loopback) | ~50 µs | Same order of magnitude as our query |
| Network round trip (across a city) | ~5,000 µs | 58 queries before the packet returns |
| Sound travels (85 µs) | ~3 cm | About the width of a thumb |
| A neuron fires | ~1,000 µs | 12 queries per neural impulse |
196 file lookups fit inside a single 60fps frame.
No flicker. No lag. Every answer back before the next frame renders.The frame test
One video frame. 196 file lookups.
At 60 frames per second, your monitor draws a new frame every 16.7 milliseconds. In one of those frames, on the same machine, we answer roughly two hundred file queries against a 4.47 million-file drive.
The thing you thought was the slow part of the system (searching through millions of files) is now significantly faster than drawing a frame on your screen.
Queries per frame
At 60 fps / 16.7 ms per frame
Queries per keystroke
USB 2.0 polls every 1 ms
Best-case query. Light makes it about four kilometers. The CPU does roughly thirty cache-line touches.
The best case
Photons make it four kilometers. The CPU does thirty cache-line touches.
14 µs is roughly thirty memory accesses to DRAM, or a few thousand instructions on a modern CPU. If you fired a laser pointer from your front door at the moment you typed the query, the result would be back before the photons reached the next neighborhood.
At that speed the bottleneck is no longer the engine. It’s the operating system’s context switch in and out of the search process, and the latency of receiving the result on the calling thread. The actual work of locating the file is somewhere down in the noise.
When software gets fast enough that the operating system becomes the slow part, it stops feeling like software. It starts feeling like a property of the hardware.
Latency budget
What 85µs means for an AI agent.
Agent file search budget
TREE WALK
per lookup
20 lookups = 2 seconds
User notices. Agent must ration searches.
INTERLINKED FILES
per lookup
20 lookups = 1.7 ms
Invisible. Agent searches freely, recursively, wastefully.
The file finder stops being a budget the agent spends carefully. It becomes a fact of the environment, like RAM.
Time budget
How much fits in one frame.
60 fps frame budget: 16,700 µs
A single traditional file search blows through six entire display frames. Our engine fits 196 queries into one. There is no perceptible latency cost, ever, on any reasonable workload.
So what
Why this matters even if you don’t care about microseconds.
An agent that needs to answer a user request might search for dozens of files while figuring out its plan. With a slow file finder (even a 100 millisecond one) those lookups dominate the wall-clock budget and the user notices the lag. With an 85 microsecond file finder, the lookups are free.
The agent can be wasteful with searches. Exploratory. Recursive. Opportunistic. It can check a hunch, discard it, check another, all before the user’s keystroke even registers at the USB controller.
The file finder stops being a budget the agent has to spend carefully and starts being a fact of the environment, like RAM. Every other part of the agent loop gets to assume search is free.
FAQ
Common questions, straight answers.
How fast is a single file search, really?
About 85 µs (85 millionths of a second) to find one file among 4.47 million on a single thread, with no server and no cache behind it. That sits roughly three orders of magnitude below the threshold of human perception, so it reads as genuinely instant.
How does that compare to tools I already use?
Finding a file is around 412,000x faster than search in VS Code, and ~480,000x faster than Windows Search, which needs about 67 seconds to work through the same drive.
What about searching inside files, not just names?
Full-text content search returns in ~7-9 ms. The same corpus takes ripgrep 93.8 s to scan cold (up to 58,625x slower) while a warm query here lands in 16 ms, because the contents are already indexed rather than walked on demand.
Why does this matter for AI agents specifically?
Search stops being a budget the agent has to ration. One measured task fell from 6m57s across 71 tool calls to 16 ms in a single call (~7,200,000x) and the share of tokens spent hunting for files dropped from ~58% to ~0%. The agent can afford to search freely, recursively, even wastefully.
What does it cost, and what does it use?
Everything local is free forever, no card, and hosting starts at $5.99/mo. At rest it holds about 44 MB of memory and keeps its index fresh within ~1 ms of a file changing. Every figure here is measured on a Ryzen 9 9950X3D across 4.47 million files.
85 µs across 4.47 million files. On a single thread. On your machine.
Not a server. Not a cache. A property of the index.