Explainer · permissionless leverage · measured July 2026
Naval said code is permissionless leverage.
Agents are the new leverage. Whether it compounds or stalls is decided one layer down: at retrieval.
In his essay series “How to Get Rich (Without Getting Lucky),” investor Naval Ravikant sorted the ways to build wealth into three kinds of leverage: labor, capital, and code and media. The first two need someone's permission: you hire people, or you raise money. The last kind needs no one's. He called it “permissionless leverage,” and it keeps working while you sleep. An AI agent is the next layer of exactly that. But an agent is leverage only while it's moving, and most of the time we measured, it wasn't. It was looking for a file.
TL;DR · the short version
Naval Ravikant sorted wealth-building leverage into labor, capital, and “code and media”: the last kind needs no one’s permission and works while you sleep.
AI agents are the newest permissionless leverage: code that now directs itself, a swarm that scales without hiring or funding.
Leverage multiplies a rate. An agent’s rate is capped by how fast it can find things, its retrieval floor. A slow floor throttles every layer above it.
Measured on a real machine: Claude Code spent 6m 57s and 71 tool calls (about 58% of its tokens) hunting one file that an index returns in 16ms, in a single call.
Interlinked makes that floor answer at memory speed (85 μs a filename, a save findable about a millisecond later), so the leverage above it actually compounds.
First, the idea
Permissionless leverage, defined.
Permissionless leverage is any tool that multiplies your output without anyone's approval: you don't hire it, you don't raise it, and it keeps producing while you sleep. Naval's example was code and media: write software once and it serves a million people; publish once and it's read while you rest. An AI agent is that same idea with a will of its own: code that now reads, plans, and edits on its behalf. Here is where it sits in the family:
| Kind of leverage | Needs permission? | Works while you sleep? | Example |
|---|---|---|---|
| Labor | Yes: you hire and manage | No | employees, contractors |
| Capital | Yes: someone must fund you | Only once invested | money, investors |
| Code & mediaNaval's pair | No | Yes | software, a post, a video |
| Agentsnew | No | Yes, and they act | Claude Code, Cursor |
The top three rows are Naval's. The bottom row is new since he wrote them: an agent is the first permissionless leverage that acts, and the first whose output is capped by something mundane. Not the size of its brain. How fast it can find things.
The stack, load-bearing floor and all
Every layer of leverage rests on one floor.
Stack the leverage the way it actually runs: you on top, your agents beneath you, the model beneath them, and under all of it the layer that finds the file, reads the code, and recalls what was decided last time. That floor is load-bearing. Slow it down and every layer above inherits the wait: the founder, the agent, the model, all standing on the same slab.
The stack can only move as fast as its floor. Leverage multiplies a rate. It can't multiply a rate that's stuck waiting on the disk. This is the same argument as the backbone of the LLM economy, drawn as a stack instead of a bedrock, and the reason the one-person company runs on retrieval.
The floor, measured
We timed the floor. It was almost the whole delay.
We watched Claude Code find a single file on this machine. Almost none of the wall-clock went to reasoning. It went to the floor. A slow floor charges the leverage above it three separate bills:
- 1
Time. 6 minutes 57 seconds of an agent digging versus 16 milliseconds, the length of a coffee run against several eye-blinks.
- 2
Money. Roughly 58% of a session's tokens (more than half of a $200 agent plan) spent reading directory listings it forgets a turn later.
- 3
Momentum. 71 tool calls to reach one file versus a single call. Every stall breaks the chain of reasoning the model was holding.
That is leverage leaking away at the base. Follow the tokens and it is stark: where your tokens go and the token cost of file hunting both land on the same culprit: the search, not the thinking.
Take the floor away
Make the floor answer at memory speed.
Interlinked Files keeps a live, always-fresh index of every file's name and contents across the whole machine, not one repo, the whole disk. A filename comes back in 85 microseconds, contents in milliseconds, a save is findable about a millisecond later, and the always-warm engine costs around 44 MB at rest, less than one browser tab. Hand that to an agent and the leverage above it stops waiting on the disk.
Then leverage does the other thing leverage is supposed to do: it compounds. The same index carries a knowledge vault of relationships it derives from your own history: no model, no guesses. Day one, on a fresh machine, it turned 8,455 git events into 26,958 connections in 1.7 seconds and, unprompted, found two repos quietly sharing 435 identical files. A floor that's both fast and getting smarter: that is what lets an agent's output keep climbing instead of flattening out.
It plugs into the agents you already run through an MCP server, and the vault that seeds itself is its own story: how the files start finding each other.
PERMISSIONLESS LEVERAGE NEEDS A PERMISSIONLESS FLOOR. NO MODEL. NO CLOUD. NO ONE'S PERMISSION.
Questions people ask
The short answers.
What did Naval Ravikant actually say about permissionless leverage?
In his “How to Get Rich (Without Getting Lucky)” series, later collected in The Almanack of Naval Ravikant, he split leverage into labor, capital, and “code and media,” calling the last kind permissionless because it needs no one’s approval and keeps producing while you sleep. This article applies that framework to AI agents; it is not affiliated with or endorsed by him.
How is an AI agent a form of leverage?
An agent is code that now reads, plans, and acts on its own, so one person can direct many at once: the same permissionless, works-while-you-sleep property Naval described for software, except it can take action instead of only running.
What is the “retrieval floor,” and why does it cap the leverage?
Retrieval is the layer that finds the file, reads the code, and recalls what was decided before. Leverage multiplies your rate of work, and an agent’s rate is throttled by how fast it can find things. On the test machine an agent spent 6 minutes 57 seconds and 71 tool calls reaching a file an index returns in 16 milliseconds and one call.
Does Interlinked run an AI model on my machine?
No. It is a live, always-fresh index of every file’s name and contents plus a knowledge vault of relationships derived from your own history: no model, no embeddings, offline and private. It hands the file and the facts to whatever agent you already use.
How do I try it, and what does it cost?
One signed installer wires up 19 AI clients at once. Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo.
Do this today
Give your leverage a fast floor.
Install once. One signed installer builds the index and auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline and the rest. No JSON, no keys.
Let it index. Filenames are searchable immediately; contents fill in behind them. At rest the whole engine sits near 44 MB, less than one browser tab.
Point your agent at it. Every connected agent now finds files at memory speed instead of walking the disk. The floor stops being the bottleneck.
Let the vault compound. Day one it knows your git history. Every week after, it knows your machine better: automatically, with no model in the loop.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.