Foundations

Agents and file systems: the recipe for AI growth.

The mismatch between a path-based interface and how agents actually read and write.

The file system was built to keep files

A file system has one job: keep files and hand them back on request. It does that job extremely well. Decades of work went into making it durable, fast, shared across a network and governed by permissions, and the result is the most widely deployed storage abstraction in the enterprise. Most of what a company knows sits on it: contracts, designs, models, recordings, spreadsheets, code.

The way those files are used has changed. AI agents now read them, compare them, search across them and write new ones, as part of tasks that run without a person in the loop. The file system did not change with them. It still answers one question, "give me the bytes at this path," and agents ask a different one: "give me what this task needs, and keep what I produce."

This post argues that the gap between those two questions is the thing holding back AI adoption on enterprise data, and that closing it is a file system problem, not an application problem. The rest of the series goes into the mechanics. This one lays out the shape.

Machines have always read files. Agents read them differently

File systems have served machine workloads for as long as they have existed. CAD and simulation suites stream large models, backup and replication jobs walk entire volumes, ETL pipelines sweep directories on a schedule, build systems read source trees. Storage has been tuned for these patterns for years, and the tuning works because the patterns are known in advance: fixed paths, predictable order, sequential or well-understood access, and a program that knows exactly which files it wants before it starts.

An agent knows none of that. It receives a task in natural language, not a path. It discovers what it needs while it works, reads a file, decides what to read next based on what it found, writes an intermediate note, reads that back, and continues. The loop runs until the task is done, and the set of files it touches is only known at the end. Several such loops may run at once, for different people, with different permissions, over the same shares.

An agent discovers which files it needs while the task runs
The loop decides what to read as it goes, so the set of files it touches is known only at the end. Nothing in the file system helps it choose; it can only answer for the path it is given.

That is the first half of the change. The second half is what happens to what the agent produces.

Everything an agent produces is a file

Agents do not only consume files. Every result they return is one: a markdown summary, a redlined contract, a spreadsheet, a slide deck, a code change, a rendered image, a transcript. A task that starts as a sentence ends as a document. This is a reversal of the last twenty years, in which work product moved out of files and into application records, because software needed a schema and a form to operate on it. A model does not. It reads unstructured input and writes unstructured output, and both sides of that are files.

The question is where the output goes. In most deployments today, it goes to the channel the task came from: a chat window, a ticket, an email, a pane in the tool that hosts the agent. Some of it is pasted into a document by hand. Most of it is read once and lost. The estate the agent read from does not receive the result, so the next agent, or the same one tomorrow, starts from the raw sources again.

What the agent produces leaves the estate it read from
The reads come from the estate. The writes go almost anywhere else.

A worked example: one renewal, three agents

Consider a customer contract coming up for renewal. Three departments touch it, and each now has an agent.

  1. Legal. The legal agent reads the signed contract, the master agreement it references, and the amendments filed since. It flags two clauses that changed in the last renewal and produces a review memo.
  2. Finance. The finance agent needs that memo, plus last year’s invoices and the current price book, to recommend pricing. It does not have the memo. It re-reads the contract and the amendments to reconstruct what legal already found, then adds its pricing analysis.
  3. Sales. The sales agent needs both outputs, plus the account’s call notes, to draft the renewal. It has neither. It reads the contract a third time, re-derives a weaker version of both analyses, and drafts from that.

The contract was read three times. Two of the three analyses were done twice. The final draft is built on less than the company actually knew, because the knowledge existed only in two chat windows that the third agent could not see. Next year, the same three agents will do all of it again from the same raw files.

None of this is a model problem. Each agent did its job well. The loss is between the agents, in the gap between the files they read and the files they never wrote.

The stack that gets built around the file system

The usual response is to build something on top: a layer that copies files out of the estate, organizes them so an agent can find them, applies its own version of who may see what, and refreshes all of it on a schedule.

Such a layer can be built, and many have been. The difficulty is keeping it consistent with the estate underneath. Every part of it reflects the files as they were at some earlier moment, and a copy begins to diverge the moment the original is edited. Agent output lands in the layer, not the estate, so the layer accumulates state that the company’s own file system never sees. For one team and a few thousand documents this is manageable. For a company, with petabytes across several storage systems and permissions that change daily, the cost of keeping it current grows faster than its value, and the layer ends up rebuilt for each agent program rather than shared.

A context layer built per agent program, each part drifting from the estate
Every arrow from the estate upward is a copy made at some point in the past. Nothing flows back down.

The recipe

The alternative is not a better layer on top. It is a file system that understands agents as a workload, the way it already understands backup jobs and CAD suites. What that takes is easier to state as three questions it has to answer at the moment an agent asks, rather than as a list of parts.

Whose permissions apply? Not the ones captured when a copy was made, but the ones in force right now, for the identity the agent is acting for. Anything else is a second permission model, and a second permission model is a liability the day it disagrees with the first.

What does this task actually need? Not a path, and not the whole corpus either. The question is asked in the language of the task, and the answer has to come from wherever the files live, which is usually several systems at once.

Where does the result go? If the answer is anywhere other than the estate it was derived from, the next task starts cold and the company learns nothing. Output has to land as ordinary files, under the same rules as their sources.

These are not three features to assemble. A retrieval tool, a permissions proxy and a write-back script can each be bought, and bolting them together produces exactly the layer described above: three components with three refresh cycles, three views of who may see what, and no single place that knows the truth.

The three questions can only be answered together, in one pass, by the thing that already holds the files and already enforces the rules. That is a file system problem, and it is why it is not solved by composition.

Run the renewal again under a file system that answers all three. Legal reads the contract once and files its memo. Finance opens the memo, adds pricing, files that. Sales opens both and drafts. One read of the raw sources, three outputs, each cheaper and better informed than the last, and all three on the estate when next year’s renewal comes around.

Agents work on the estate directly and file their output beside the sources
Compare this with the previous map. The layer is gone, the copies are gone, and the arrows between agents are files.

Knowledge compounds or it evaporates

Andrej Karpathy made a similar observation about a single person’s notes in his LLM Wiki note: a model that re-derives everything from raw documents on each query never gets better, while one that writes what it learns into durable files it can read next time does.

The same rule applies to a company, with one difference of scale. A person has one folder. A company has petabytes, several storage systems, thousands of agents and a permission model that no single file may violate. The compilation has to happen inside the file system, per task, under the rules the storage already enforces, or it does not happen at all.

Agents and file systems grow together or not at all, and the growth is measured in files: every task either leaves the estate richer than it found it, or leaves it exactly as it was and spends the next task finding the same things again.

The posts that follow take the pieces one at a time: what changes when a file system serves thousands of agents instead of hundreds of people, how many agents share one estate without stepping on each other, why access has to be decided at the moment an agent asks, what it means to compile rather than retrieve at enterprise scale, and a measured look at how much of an agent’s work today goes to finding files.

The series

Get the next post.

One email when the next piece in the series goes up. No product news, no sales follow-up.

Unsubscribe in one click. We do not share the list.

Next

More from the series.