Personal Compute in the Age of AI Agents

Two new offerings, two philosophies, and what they tell us about where computing is going

Two cloud offerings launched recently that are worth paying attention to. Both are explicitly built for the age of AI agents. Both reject serverless complexity. But they represent different philosophies about what "personal compute" means now.

Sprites.dev is Fly.io's new product. exe.dev is a new company entirely. Together they sketch the outline of something emerging.

Fly.io team member Thomas Ptacek described Sprites as "BIC disposable computers"—like the box of ballpoint pens you scatter across your house so you always have one handy. Ephemeral sandboxes you spin up, use, and throw away.

The technical innovation is checkpoint and restore. Sprites can snapshot their entire disk state in about 300 milliseconds, enabling rollback to any previous point. They scale to zero when idle—you're charged only for actual use, roughly $0.46 for a four-hour coding session.

This is simplicity through disposability. Don't maintain state—checkpoint it. Don't worry about messing things up—restore. The computer is ephemeral, so you treat it as ephemeral. Use it, toss it, spin up another.

Fly built Sprites for two use cases that turn out to be the same problem: running coding agents in "YOLO mode" (letting them do whatever without fear of consequences) and executing untrusted code in sandboxed environments. Both need isolation. Both need to be throwaway.

exe.dev takes a different stance. Their tagline is "persistent disks, not serverless." Where Sprites are disposable, exe.dev VMs are durable. Where Sprites scale to zero, exe.dev machines are just... there.

The model is subscription: $20/month gets you a resource pool—2 CPUs, 8GB RAM, 25GB disk—and you can spin up as many VMs as you want within that pool. The VMs share resources. You're not paying per instance. You're paying for access to compute itself.

Traditional cloud hosting charges per machine per month. Serverless charges per request or compute-second. exe.dev charges a flat rate and lets you carve it up however you want. Twenty-five VMs doing small things, or five VMs doing bigger things, or one VM when that's all you need. The economics shift from "is this worth spinning up?" to "I have compute, might as well use it."

The UX is slick in a way that matters. You sign up by SSHing: ssh exe.dev new. There's an email confirmation, but it all happens within the SSH session—the system accepts whatever key your machine offers and puts it on file. If you're already using Claude Code—which means you're already comfortable in a terminal—you're running in seconds.

Here's what I think these offerings are pointing at: personal compute is bifurcating.

When people talk about compute in the AI age, they usually mean inference compute—the GPU cycles that run the models. Sam Altman has floated visions of "compute allowance" as a kind of UBI, where everyone gets a budget of AI thinking. That's one half of personal compute.

The other half is environment compute. The old-fashioned kind. A computer where things actually happen—where agents run, where code executes, where files live. The computer as workspace, not the computer as brain.

We've always had this. It was called your laptop. But agents change the equation.

Agents are increasingly long-running. A coding agent working on a complex task might run for hours. A research agent might run overnight. An automation might need to be available continuously.

Your laptop can't host that. It sleeps. You close it. You're on a plane. The agent needs somewhere to live that isn't tethered to your physical presence.

This is obvious in retrospect. We've had servers forever. But the framing is different now. It's not "I need to host an application for users." It's "I need a computer for my agent to live in."

This isn't developer infrastructure anymore. It's personal computing infrastructure. The distinction matters because the audience is different. Developers have always known how to spin up EC2 instances. But the person using Claude Code to build a personal project—they might never have provisioned a server before. They need something that feels like a consumer product.

There's another shift happening alongside this: app hosting is becoming a consumer concern.

Claude Code is enabling a new kind of personal software. People are building one-off applications for themselves—tools that solve their specific problems, automations that fit their specific workflows. This has always been possible, but it was gated by implementation skill. That gate is lower now.

But personal software wants to be shared. You build something for yourself, and then you want to show your family. You make a tool that helps you, and you think your friend could use it too. Suddenly you need hosting. Not for a startup, not for a business—just to share a thing you made.

This is hosting as a consumer product. Not "deploy your SaaS" but "share your thing." exe.dev's model fits this: spin up a VM, put your app on it, share the URL. It's within your resource pool, so it doesn't cost extra. The barrier between "I made this" and "you can use this too" drops to nearly nothing.

The two offerings represent different philosophies, and both are right for different moments.

Sprites are for sandboxing. When you need isolation, when you're running untrusted code, when you want to let an agent go wild without consequences—checkpoint, restore, throw away. The disposable computer for disposable tasks.

exe.dev is for persistence. When your agent needs a home, when you're hosting something you want to keep running, when you want a computer that's just there like your laptop is just there—but in the cloud, always on, accessible from anywhere.

Both are rejecting the serverless abstraction. Both are saying: sometimes you just want a computer. The interesting question is which kind—the one you throw away, or the one that sticks around.

I suspect exe.dev's model is the more consequential one for what's coming.

Not because disposable sandboxes aren't useful—they are. But because the "computer for my agent" use case is about to explode, and subscription compute with shared resources is exactly the right economic model for it.

You don't want to think about whether spinning up another VM is worth the incremental cost. You want to have compute available and use it freely. You want the cloud to feel like your laptop feels—there when you need it, not metered by the minute.

That's what exe.dev is selling. Not VMs. Not hosting. A personal computer that happens to be in the cloud. Multiple personal computers, actually, for the price of thinking about zero of them.

This is what personal compute looks like in the age of agents. Inference on one side, environment on the other. Both subscription. Both just... there.