Agents · measured July 2026 · 8 min read
Jensen Huang says every company is an AI company. They will all hit the same wall.
NVIDIA's founder and CEO has said it for years, on keynote stages and in interviews: every company will become an AI company. Not every company will use AI: every company will be built on it. Take him at his word and one thing falls straight out: every company will run agents, at scale, all day. And every agent, in every industry, hits the same wall before it can do anything useful.
The wall is not the model. It is retrieval: finding the right file across the machine before the thinking can start. On a real drive we timed an agent doing exactly that. Left to its own tools, Claude Code took 6 minutes and 57 seconds. With an index underneath it: 16 milliseconds. The number sounds like a typo. The methodology makes it boring.
TL;DR · the 60-second version
- 01
Jensen Huang, NVIDIA's founder and CEO, has said it for years and on the record: every company will become an AI company. Taken literally, that means every company will run AI agents.
- 02
An agent is only as good as the context it can retrieve. Before it can reason it has to find the right file. And that step, not the model, is the slow and expensive floor under everything above it.
- 03
Measured on one real machine: Claude Code took 6 minutes 57 seconds and 71 tool calls to find a single file. With a live index it was 16 milliseconds and one call, about 7,200,000× lighter.
- 04
The floor is the same for a bank, a hospital, or a solo developer. Finding a file by name took VS Code 35 seconds and Windows Search 67; the index answered in 85 microseconds.
- 05
Interlinked Files is that floor: a whole-machine, always-fresh index plus a knowledge vault, offline, no model in the box, one install wiring up 19 AI clients.
Take the premise literally
A bank, a hospital, a solo dev. One floor under all of them.
An AI company, stripped to its mechanics, is a company that runs a swarm of agents against its own files: code, contracts, records, tickets, the drive nobody cleaned up. The industries could not be more different, but the first move is identical every time: before an agent can act, it has to find the thing it needs. That is the retrieval floor (the layer that turns “where is the auth config?” into an actual file), and it is the same floor whether the machine belongs to a trading desk or a game studio.
Draw the premise honestly and it is a funnel. Every company pours in at the top. They all become AI companies; they all run agents; and every agent, regardless of the business above it, squeezes through the same narrow gate at the bottom.
Huang's own sharper line, from GTC 2017, points at the same gate: “software is eating the world, but AI is going to eat software.” If AI eats software, then software's oldest chore (finding the file) does not disappear. It moves under the agent, runs millions of times a day, and becomes the thing that decides how fast the whole company moves. This is the umbrella argument in the backbone of the LLM economy, pointed at Huang's premise instead of one developer.
One agent · one file · measured end to end
We watched an agent hit the wall.
One instruction. To carry it out without an index, Claude Code walked the tree, read files, searched their bytes, and searched again: 71 tool calls before it touched the right one. With an always-warm index answering in its place, the same task needed a single call.
End to end (time, tool calls, and tokens folded together), that one workflow came in about 7,200,000× lighter: six minutes and fifty-seven seconds of an agent grinding, long enough to make a coffee, against a result gone before you look up. Then remember Huang's premise is not one agent finding one file. It is every company running that loop all day. Multiply the waste by the swarm and the number stops sounding like a boast and starts sounding like a bill, most of it spent on directory listings the model reads once and forgets a turn later, the same tax the one-person company pays.
Same machine · same drive · same queries
The same lookup, everywhere a company would run it.
| The searcher | The task | Time | vs Interlinked |
|---|---|---|---|
| Interlinked | one indexed lookup | 85 µs | baseline |
| VS Code (Ctrl+P) | the same file, same drive | 35 s | 412,000× |
| Windows Search | median of 20 queries | 67 s | ~480,000× |
| ripgrep (your agent's content search) | same query, same corpus | 93.8 s → 16 ms | 58,625× on the set |
| Claude Code (no index) | the full find-one-file run | 6 m 57 s → 16 ms | ~7,200,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Single-file lookups are a median 85 µs (best case 2 µs); the 20-query median across the whole drive was 139 µs, ~480,000× ahead of Windows Search's 67 s. The ripgrep row is one content query timed both ways: 93.8 s walking the disk, 16 ms indexed; the 58,625× figure is the median speedup across the content set. The Claude Code row is the end-to-end measured run: wall time, 71 → 1 tool calls, and tokens folded in. Full per-tool methodology in the 412,000× VS Code write-up and the ripgrep comparison.
Why the floor is slow for everyone
You can rent a smarter model tomorrow. You can't rent a faster floor.
Every agent re-hunts from scratch. VS Code indexes the folder you opened; Cursor indexes the repo you're in: each tool understands one project in isolation. But an AI company does not live in one repo. It is a dozen that ship together, plus the records, the exports, the config with the answer that was never in git, and an agent's questions do not respect folder boundaries. So the swarm falls back to the oldest tools on the machine, walking the disk on every single query, because nothing warmer exists across the whole machine.
A pre-indexed engine that stays warm in the background turns that floor into bedrock. It sits at about 44 MB idle, keeps its index under 1% of the drive, and a file you just saved is searchable in about a millisecond, under 30 in the worst case. One install wires it into 19 AI clients at once, so every agent asks the same instant layer. That is the entire idea: make the layer every agent stands on answer at memory speed.
The floor the premise assumes
Speed finds the file. Memory knows why it matters.
Interlinked Files is that retrieval floor, built as the layer under every agent instead of inside any one of them. The same index that answers in microseconds also carries a knowledge vault the engine builds by itself: files that change together, repos that share hundreds of identical files, notes any agent can leave on any file that every other agent reads. Keyed to each file's identity in the operating system, so it survives renames and spans every repo. No model in the box, no embeddings, no cloud round-trip: every relationship is a count or a hash you can check, and nothing ever leaves the machine. Not a replacement for RAG or your model's memory, the layer under both.
EVERY COMPANY BECOMES AN AI COMPANY. EVERY AI COMPANY STANDS ON A FLOOR. WE MADE THE FLOOR INSTANT.
Questions people ask
The honest FAQ.
Did Jensen Huang endorse Interlinked Files?
No. He has never mentioned us and this implies no sponsorship. He has said, repeatedly and on the record, that every company will become an AI company; this article takes that premise seriously and follows it to the retrieval floor every agent stands on. The famous name is the doorway, not an endorsement.
What did Jensen Huang actually say?
For years, across keynotes and interviews, he has framed it the same way: every company will become an AI company, and every company will need to build with AI rather than merely buy it. Back at GTC 2017 he put a sharper version of it on stage: “software is eating the world, but AI is going to eat software.” Both lines are his, and both are public.
Why is finding files the bottleneck and not the model?
Models keep getting faster and cheaper; the step that has not is retrieval. Before an agent can think, it has to locate the right file across the whole machine, and it usually does that by walking the disk. On 4.47 million files that walk took 93.8 seconds for one content query; a prebuilt index answered the same query in 16 milliseconds. See the backbone of the LLM economy.
How is this different from the search already in my editor?
VS Code indexes the folder you opened; Cursor indexes the repo you are in. A real machine is a dozen repos that ship together plus the 90% of the disk that was never in git: configs, downloads, the PDF with the answer. Interlinked indexes the whole machine, including git-ignored files, and every agent shares the same index through one MCP server.
Does anything leave my machine, and what does it cost?
Nothing leaves. There is no model, no embeddings, no cloud round-trip: a query is a lookup against a local index. The engine sits around 44 MB at rest and its index stays under 1% of the drive. Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo.
Do this today
Give your agents the floor.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline 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 (less than a browser tab) and stays a millisecond behind your saves.
Ask normally. Your agent picks the right tool by itself. You just ask where something is, or what mentions it; the answer comes back in microseconds, whole-machine, including the git-ignored files.
Let the vault grow. Day one it already knows your git history. Every week after, it knows your machine better, automatically, offline, and it never leaves the disk.
Huang never heard of us. That is the point. “Every company is an AI company” is a claim about leverage, and leverage needs a layer that finds and remembers everything on the machine, instantly. Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.