What 85 microseconds actually feels like.

• 01A microsecond is one-millionth of a second. 85 of them is roughly a thousandth of a single blink.
• 0285 µs is how long one file lookup takes on the test machine, one name found among 4.47 million files. Best case: 2 µs. Median across 20 queries: 139 µs.
• 03In the time you blink once (~100 ms), the engine could run that search about 1,176 times, back to back.
• 04The tools you already use are slower by a factor most people read as a typo: VS Code takes 35 seconds for the same file, Windows Search 67 seconds. That's 412,000× and ~480,000× slower.
• 05Fast enough that, for an AI agent, finding a file stops being something it waits on. It becomes free, like reading from memory.

A microsecond is one-millionth of a second: the sliver of time in which light, the fastest thing there is, travels about 300 metres. 85 microseconds is how long Interlinked Files takes to find one specific file, by name, among 4.47 million on the benchmark machine (a Ryzen 9 9950X3D, 64 GB DDR5, NVMe, Windows 11). The best case is 2 microseconds; the median across 20 different queries is 139.

Human perception rounds all of that to zero. The quickest blink of an eye lasts about 100 milliseconds. That is 100,000 microseconds. Line them up and one blink is long enough for roughly 1,176 of these lookups, one after another, before your eyelid finishes rising. You would never see it happen. It is three orders of magnitude below the threshold where a human can tell that time has passed at all.

For the deeper, nerdier version of this (cache lines, DRAM, photons), see the physics of microseconds. This piece stays with the things you can feel.

Why a small number is a big deal

When search costs nothing, an agent stops rationing it.

For a person, 85 µs and 100 ms are both just “instant.” For an AI agent running hundreds of file lookups to plan one change, the gap between them is the whole session. On the same machine we watched Claude Code spend 6 minutes 57 seconds and 71 tool calls hunting for context the slow way. With the index in place it was 16 milliseconds and a single call, and the roughly 58% of its tokens that had been going to file-hunting fell to almost none.

Search stops being a budget the agent has to spend carefully and becomes a fact of the environment, like RAM. Every other part of the loop gets to assume it is free. That is where all your tokens actually go, and it is why one small number changes the whole shape of a session.

What is a microsecond?

One-millionth of a second. 85 of them is about a thousandth of a single blink; a million of them is one second. It is far below the roughly 100-millisecond threshold at which a human can perceive that any time has passed.

Is 85 microseconds the real, measured number?

Yes. It is a single-file lookup on the benchmark machine: a Ryzen 9 9950X3D, 64 GB DDR5, NVMe, Windows 11, with 4.47 million files indexed. The best case is 2 µs; the median across 20 different queries is 139 µs. Nothing is estimated.

How is that possible when Windows Search takes over a minute?

Windows Search (and tools like VS Code and grep) walk the disk when you ask, every time. Interlinked keeps a live, always-current index of every file, so the answer is looked up, not hunted for. The same 20-query set that takes Windows Search 67 seconds returns in 139 µs, about 480,000× sooner.

Does it stay this fast as files change?

Yes. A saved change is searchable in about a millisecond, worst case under 30. The index stays under 1% of the drive and the background engine idles at around 44 MB of memory, so speed does not decay as the machine fills up.

Why would an AI agent care about microseconds?

Because it runs the search hundreds of times per task. At 85 µs each, those lookups vanish into the noise; at 100 ms each they become the slowest thing the agent does. The difference is a whole session of wasted time and tokens.