Agents need computers, not compute

In January 2026, Apple Stores across the U.S. ran out of M4 Pro Mac Minis. The 48GB and 64GB configurations went first. Delivery times stretched to five and six weeks.

The reason wasn’t a chip shortage or a product refresh. People were buying them to run AI agents. Specifically OpenClaw: a persistent agent environment that needs a filesystem, a process that stays running, and a workspace to return to.

OpenClaw doesn’t use the Mac Mini’s GPU. It sends API calls to cloud providers for inference. The Mac Mini’s job is to be a computer. People are buying computers for their agents, not compute.

Agents need computers, not compute.

Fifteen years of cloud infrastructure abstracted away the machine. Functions, not filesystems. Stateless, ephemeral, and billed by the invocation. That model was right for web requests. It was never designed for agents.

People assume the infrastructure problem for agents is cost. Inference is expensive, cloud bills are unpredictable, and GPUs are scarce. Those are real constraints. They’re the wrong diagnosis.

Consider what an agent actually does on a non-trivial task. It starts working. It discovers it needs a library that wasn’t in the original environment, so it runs pip install. It writes intermediate results to disk because holding everything in memory across a three-hour session isn’t practical. Three steps later, it reads those files back. The next morning, it returns to the same workspace and picks up where it stopped. When it’s done, an operator inspects what happened, file by file, to understand the decision trail.

Every one of those operations assumes a computer. A persistent environment with a filesystem, a package manager, and a state that survives across sessions. None of them are things a function invocation does.

A web request passes through infrastructure. An agent inhabits it. That distinction turns infrastructure from a procurement decision into a product decision.

The gap

AWS Lambda runs for up to 15 minutes. It can’t pip install mid-execution because the filesystem is ephemeral. There’s no concept of “return tomorrow.” There’s no file tree for an operator to inspect afterward. The execution model is stateless by design: clean entry, clean exit, and no residue.

That isn’t a limitation. It’s a deliberate choice for a specific workload. Web requests don’t need to return tomorrow. HTTP doesn’t need a package manager. The abstraction was correct.

The abstraction went too far for agents.

Serverless containers extended the timeout. But the architectural primitives stayed the same: ephemeral filesystem, stateless execution, and metered by duration. Agents need more than a longer timeout. They need an environment they can modify, a filesystem that persists across sessions, a workspace that’s still there tomorrow.

Without those primitives, the application layer fakes them. It writes state to an external database between each step, reconstructs environment configuration on every invocation, and serializes the context that a persistent environment would just keep.

The overhead isn’t incidental. It’s a capability ceiling. Every feature the agent can’t do because the environment won’t hold state is a product decision made by default.

What the builders are revealing

The companies building agent compute are interesting for what their product choices reveal about the gap.

Daytona describes its product as “a computer for every agent.” That framing is precise. Not a function invocation, not a container with a longer timeout. A computer: persistent, inspectable, and forkable. Daytona sandboxes can snapshot state, branch into parallel versions, pause for human review, and resume exactly where they stopped. That capability maps directly to what agents need: a workspace that persists, a history that can be inspected, and an environment that can branch before a risky action.

Perplexity named the same primitive differently. At their Ask 2026 conference on March 11, they announced a product called “Personal Computer”: an AI layer running on a user-supplied Mac Mini with persistent, always-on access to local files, apps, and sessions. CEO Aravind Srinivas: “A traditional operating system takes instructions; an AI operating system takes objectives.”

Daytona calls it “a computer for every agent.” Perplexity calls it “Personal Computer.” That’s not a naming coincidence.

E2B takes the isolation angle with Firecracker microVMs, an Apache 2.0 license, and pay-per-second billing. Full Linux environments that operators can inspect and audit. The open license matters: regulated industries won’t deploy agents into environments they can’t audit. E2B is building the floor under that ceiling. The primitive is a contained computer, not a metered compute burst.

Modal’s wager is different. Not persistence, but scheduling: containers that spin up in milliseconds and run for hours, GPU-native. Long-running agent workloads look like data pipelines, not web requests. You don’t get fork-and-resume from this primitive. You get compute economics that work for the task duration.

Each product is a different answer to the same question: what kind of computer does the agent need? The answer is a product bet, not a vendor preference.

What the environment makes possible

The infrastructure question isn’t “which cloud provider.” It’s: what kind of environment does this agent need to inhabit?

Take a coding agent running a risky refactor. On ephemeral compute, it runs the change and commits to the result. There’s no branch, no rollback. In a forkable environment, it copies the workspace first, runs the refactor in the copy, checks if tests pass, and merges only if they do. That capability didn’t come from a better model. It came from the environment primitive.

Or a research agent that runs for two hours and gets interrupted. On stateless infrastructure, it reconstructs context from a database: re-fetch, re-parse, and re-derive. On a persistent computer, it opens the files it left on disk. One is a workaround. The other is how computers work.

The choice of environment sets the ceiling. Every feature built on top inherits the constraints of the primitive underneath.

What compute doesn’t close

The Mac Minis that sold out in January were just the start. By March, the shortage had spread to Mac Studios. Apple quietly dropped the 512GB RAM option entirely, raised the 256GB upgrade price by 25%, and delivery times stretched to 10-12 weeks. The demand isn’t slowing down. It’s compounding.

The cloud made compute a commodity. Generic, interchangeable, and metered by the second. Agents are reversing that. The people buying these machines understood something the cloud abstraction had obscured: their agents needed a place to live. Not cycles. Not invocations. A computer.

The environment an agent inhabits isn’t overhead. It’s product surface.