The agent-scale
folder

The folder is one of the oldest ideas in computing. It is about to have far more users.

For more than fifty years the folder has had one kind of user: a person at a computer, opening one file at a time. That person is slow. They read a few files a day, save a few more and go home at night. Everything we built around folders, from sync clients to shared drives, assumed someone like that.

Then agents arrived, and the first thing they did was reach for files. Ask Claude Code or Codex to do something and watch what it does. It lists a directory. It opens a markdown file, greps for a name, writes a plan to disk and picks it up an hour later. Nobody designed agents to work this way. Files were simply what they had seen most of, and files already worked.

So the folder is about to get a new kind of user, and a lot of them. A team of five might run fifty agents. A company might run thousands at once, each in its own sandbox, all reading and writing the same files. A folder used to have one person in it. Now a thousand processes want in at the same time.

That raises a question that turns out to be more interesting than it sounds. What does a folder look like when most of its users are agents?

The obvious answer is a normal folder, only faster. That answer is right, and nearly all the work hides inside the word “faster”.

Take search. A person searching a folder types a few words and scans the results. An agent searches the way it writes code. It runs grep for an exact string, tries a regular expression, narrows to one directory and reads the twenty lines around the match. If the answer isn’t there, it changes the pattern and runs it again. It might do that thirty times in a minute.

On a laptop that works, because the disk is right there. On a shared drive in the cloud it falls apart. Every grep turns into thousands of trips over the network, and the agent spends its time waiting where it used to spend it thinking.

So an agent-scale folder has to answer code-shaped questions across the whole drive, at once, and the agent should never have to know anything changed. It keeps writing grep. The folder does something very different underneath.

Writing changes the same way. When a thousand agents work in one folder, two of them will sooner or later save the same file from different versions. A folder built for people gets away with letting the last save win, because people rarely collide. Agents collide all day. So the folder has to notice a stale write and refuse it, every time, cheaply.

None of this is exotic. It’s what a folder has to be once you take its new users seriously. And it leads to something we learned the hard way: don’t be afraid to rewrite old technology for a new era.

There is a strong instinct in software to leave the foundations alone. Postgres works. Folders work. Rewriting either sounds like what ambitious programmers do before they learn better. But foundations are built for the users of their time. When the users change enough, the old design starts to show its assumptions, and the way past them is to rebuild the part that holds them.

We’ve done this twice. When we built our first product, Polygres, we rebuilt Postgres in Rust as our own serverless graph and vector layer. It taught us how far a database can go once you stop treating its original design as fixed.

When we built WonderSearch, we rebuilt the way data gets indexed, so you could search it with code. That one surprised us most. In our own evals, letting agents search with grep and regular expressions gave them better and more flexible search than anything else we tried. Each rewrite felt reckless at the start and obvious at the end.

Paul Graham once wrote that the way to find a startup idea is to live in the future, then build what’s missing. That is what happened to us. We were already living with agents in our files, and the thing missing was a folder built for them.

So we put everything we’ve learned into one product, the one we should have built all along: a folder for a team and every agent it runs. It mounts like any folder on a Mac or a Linux machine, and agents without a file system reach it over MCP. Search works the way agents already write code, across every file in the drive. A write made against an old version is refused, so nobody silently overwrites anybody.

It looks like a folder because it is one. That was the point. The oldest idea in computing turned out to be the right interface for its newest users. It just had to be rebuilt for them.

The most powerful drive
in the world.

And we’re calling it FlashDrive.