Explainers · measured July 2026
Sam Altman predicted the one-person company. Here is the layer it runs on.
Altman has said, publicly and more than once, that he expects to see the first one-person billion-dollar company, and that founders he knows keep a running bet on which year it lands. He was describing ambition, not a product. But take the prediction literally and one thing falls out immediately: one human cannot do a billion dollars of work, so the AI does it: a swarm of agents, running in parallel across every project on the machine. The bottleneck for that founder is not the models. It is context: every agent, on every task, has to find the right files across the whole machine and remember what was already learned.
On a real machine we timed the swarm's single most common move: finding one file. 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.
Take the prediction literally
One founder can't scale. A swarm of agents can, if they can find things.
Here is the shape of the one-person company, drawn honestly. The founder sits at the top and issues intent. A swarm of agents (whichever ones you like, reshuffled weekly) does the parallel work. And every one of them, on every task, reaches down to the same place: the files on the machine and the memory of what was learned there. Change the models out for smarter ones tomorrow; the bottom layer is what they all still stand on.
The models are rented and interchangeable. The swarm is fluid. What does not change is the machine (a dozen repos, the documents, the configs, the 90% of the disk that was never in git) and the layer that answers questions about it. Make that layer instant and the whole swarm speeds up at once. Leave it slow and it is the ceiling on everything above it. This is the umbrella argument in the backbone of the LLM economy, pointed at one founder instead of the whole industry.
One agent · one file · measured
We timed the swarm's most common move.
End to end (time, tool calls, and tokens together), that one workflow came in about 7,200,000× lighter. It reads like hype until you see how it is built: on a Ryzen 9 9950X3D, 64 GB DDR5, NVMe, Windows 11, across 4.47 million files, the without-index run is the agent shelling out to directory listings and byte-walking greps, and the with-index run is a single pre-indexed lookup. Then remember the founder is not running one agent finding one file. It is a swarm, all day, every task. So multiply the waste by the swarm and the number stops sounding like a boast and starts sounding like a bill.
Same machine · same drive · same queries
The same lookup, everywhere a swarm would run it today.
| The searcher | The task | Measured | 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× |
| Claude Code (no index) | one file, measured end to end | 6 m 57 s | ~7,200,000× |
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Filename lookups compare against the 85 μs single-file time; the median of 20 filename queries is 139 μs, ~480,000× ahead of Windows Search's 67 s. The ripgrep row is a content query: 58,625× across the set, with the proof query going 93.8 s → 16 ms. The Claude Code row is the measured agent run: end to end, including the 71 tool calls and the tokens it collapses into one indexed call, not a single-operation stopwatch ratio. Full per-tool write-ups in the 412,000× VS Code comparison and the ripgrep content-search benchmark.
Why the model isn't the constraint
You can rent a smarter model tomorrow. You can't rent a faster floor.
Every agent in the swarm 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 the one-person company does not live in one repo. It is a dozen that ship together, plus the documents, the downloads, the config with the answer, 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 in the swarm asks the same instant layer. That is the entire idea: make the layer every agent stands on answer at memory speed.
The tiny proof is our own machine
One person. Twelve repos. One index that already knew how they fit.
The dev machine this product is built on is the one-person company in miniature: one human, a swarm of agents, a dozen projects that ship together. Speed finds the file, but the founder also needs the agents to remember. So the same index carries a knowledge vault it builds itself. On first run it read the machine's own git history and webbed the whole thing together, before a single search. And it did it with no LLM, no embeddings, every relationship a count or a hash you can check. Not a replacement for RAG or your model's memory: the layer under both.
Because every note is keyed to the file's OS identity, the memory survives renames, spans every repo, and belongs to no vendor: the fix for the problem where an agent's memory dies on rename. The full seed, timed from the service log, is in files that find each other.
SPEED FINDS THE FILE. MEMORY KNOWS WHY IT MATTERS. THE ONE-PERSON COMPANY NEEDS BOTH.
The layer the prediction assumes
Give the swarm its bedrock.
Install once. One signed installer wires the same instant layer into 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 fills in behind it. At rest the whole engine sits around 44 MB and its index stays under 1% of the drive.
Let the vault grow. Day one it knows your git history: 12 repos webbed in 1.7 seconds. Every week after, it knows your machine better, automatically, offline, with no model in the box.
Altman never heard of us. That is the point. The one-person company is an argument about leverage, and leverage needs a layer that finds and remembers everything on the machine, instantly. That layer is unglamorous. It is also the whole game.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.