Deep Dive: AetherFS and the Filesystem-First Future of Agent Infrastructure

How a Rust-based overlay filesystem is challenging the per-agent VM as the default substrate for autonomous coding agents.

Agent infrastructure spending has been the fastest-growing line item in cloud bills for two consecutive years. The dominant suppliers (e2b, Modal, Daytona, and the hyperscaler sandbox products) have built durable businesses by treating compute as the unit of value. Pay for the VM-second, run the agent, repeat at scale. The category has matured quickly, with pricing converging toward commodity ranges and feature parity narrowing the gap between vendors.

Underneath the compute layer, however, a quieter argument has been forming about what the actual bottleneck for agent throughput looks like. The argument, paraphrased from the small group of teams that have started shipping it as product, is that the bottleneck is not CPU. It is the filesystem. Specifically, the time and cost of materializing a workspace from scratch every time an agent runs, rather than forking it from a shared base.

AetherFS, a Rust-built distributed overlay filesystem currently in private beta, is the most articulated bet in this direction.

The Compute Layer Got Commoditized First

The trajectory of agent compute over the past 30 months mirrors the trajectory of every infrastructure category that came before it. A first generation of vendors emerged with proprietary stacks and aggressive feature differentiation. A second generation arrived with open standards and lower prices. The category settled into something resembling a commodity, with pricing competition replacing feature competition as the primary axis.

e2b, Modal, and Daytona have each carved out durable positions in this market. e2b focused on language-runtime breadth and developer-friendly APIs. Modal built a broader compute substrate and applied it to agent workloads as a natural extension. Daytona pivoted into agent-native dev environments after starting as a CDE company. The hyperscalers added agent-friendly modes to their existing serverless products. The functional differences between these offerings, from the perspective of an agent platform builder, are now narrower than they were a year ago.

When a category commoditizes, alpha moves up or down the stack. Up the stack means orchestration, model routing, evaluation infrastructure, the layers closer to the agent itself. Down the stack means storage, state management, the layers underneath compute that have been treated as plumbing. The down-the-stack movement is happening more quietly than the up-the-stack one, which is part of why it is interesting. The teams that have noticed the opportunity at the storage layer are not the established compute vendors. They are new entrants with infrastructure-engineer DNA, building from the assumption that the filesystem is the actual scarce resource.

This pattern is recognizable. It is what happened when CDNs commoditized and storage became the next layer of differentiation. It is what happened when compute commoditized and storage-as-a-service emerged. The mechanism repeats.

The AetherFS Origin

AetherFS reads more like infrastructure than like a wrapper, which is itself a useful signal. The codebase is approximately 18 packages of Rust. The system exposes 12 gRPC services, with HTTP, WebDAV, and FUSE access surfaces layered on top. There is a content-addressable store underneath the overlay layer, with reference counting and a Moka-backed LRU cache for memory bounds. Persistence flows through a RocksDB journal to an S3-compatible backing store. The technical surface area is closer to a database than to a typical developer tool.

The team's positioning, paraphrased from public design materials, is built around a specific claim about where the agent infrastructure stack went wrong. The claim is that the filesystem has been the wrong layer of abstraction since the start. Compute companies have treated workspace state as an output of their product. Agent platforms have treated it as a side concern. Nobody has built it as the primary product, which is why every agent platform has ended up building some version of it internally, badly, in parallel.

The choice of Rust is intentional. The team has argued, in public technical writeups, that a substrate that touches the filesystem cannot afford the latency variance of a garbage-collected runtime, especially when the substrate is going to be hit by thousands of concurrent sessions on a single node. Rust is not the only language that meets the constraint, but it is the most production-ready choice for the workload, and the developer pool for systems-level Rust has grown enough in the past two years to make it a viable hiring base.

The early-stage signaling around AetherFS has emphasized infrastructure credibility over product polish.

What an Agent Actually Needs

The core architectural commitments map cleanly to the four characteristics that define an agent-friendly substrate.

Sessions are copy-on-write overlays on a shared base. Forking a session is an O(1) metadata operation regardless of base size. The team's published target is sub-10-second session materialization for typical workloads, against the 90-to-180-second cold start that per-VM architectures deliver.

Deduplication happens at the content-addressable layer. Two sessions writing the same file path with the same content store one copy of the bytes, with reference counting tracking the rest. The team has described per-session storage costs in the sub-1-percent range relative to base size for typical edit patterns. The number depends on workload, but the architectural shape of the claim is verifiable from the design.

State portability comes from the multi-protocol surface. The same session is addressable through gRPC for agent backends, HTTP for build pipelines, WebDAV for casual access, and FUSE for local mounts by humans or container workloads. The session ID is the connecting reference. A backend can create a session over gRPC, hand the ID to a CI system that hits it over HTTP, and let a human engineer mount it locally over FUSE for review. None of these transitions requires serialization.

Determinism is partially addressed at the substrate level. The same session ID produces the same starting state across mounts. The agent's own non-determinism (model temperature, race conditions, external API state) is out of scope for the filesystem, but the substrate guarantees the part it can guarantee, which is more than current alternatives offer.

From One VM Per Agent to One Session Per Thought

What the architecture unlocks, in concrete terms, is a different unit of agent work. The current per-VM architecture treats one agent run as one machine-lifetime: spin up, do work, tear down. The overlay-session architecture treats one agent run as one session-lifetime, which is cheap enough to be created at the granularity of a thought.

A planning agent that wants to evaluate ten possible refactors does not have to pick one. It forks ten sessions, runs them in parallel, compares the outputs, and discards nine. A debugging agent that wants to test a hypothesis does not have to commit to the hypothesis: it forks, tries, and reverts by discarding the session. A multi-agent system that wants to explore branching solution paths does not have to coordinate state across machines: each branch is a session, addressable by ID, durably stored.

The team has framed this shift in public materials as a move from "per-agent VM" to "per-thought session." The framing is marketing, but the underlying pattern is real. The per-VM model imposed a cost structure that made exploration expensive. The per-session model removes that cost structure. What that unlocks for agent workflows is the part that is still being discovered.

Where Value Moves Next

Analyst observation, with the standard speculation flag. As compute commoditizes, the moats in agent infrastructure shift down the stack to state management and the developer-agent interface, and up the stack to orchestration and evaluation. The middle layer (the VM, the container, the sandbox) will continue to exist but stop being where the interesting product work happens.

AetherFS is a coherent bet on the down-the-stack move. The bet is not yet proven. The company is in private beta, the design partner roster is not yet public, and the architectural argument has not been validated by adoption at scale. But the direction is the right one to be looking, and the team's articulation of the bet is the clearest external version of an argument that has been forming privately at every serious agent platform for the past year.