# Cloud computers for AI coding agents: 8 compared
> exe.dev, Sprites, boxd, shedix, Codespaces, E2B, Daytona and Modal for coding agents, priced for the same box, with what each does when idle.
*2026-11-11 · agents, remote-dev, costs*
A cloud computer for an AI coding agent is a Linux box away from your laptop where the agent can install tools, run tests and keep working while you're gone. There are three kinds: whole machines that last (exe.dev, Sprites, boxd, shedix), dev environments for a person at an editor (GitHub Codespaces), and sandboxes your code creates from an SDK (E2B, Daytona, Modal).
We make shedix. Every other figure comes from each provider's own pages, linked, as of 2026-11-11.
## What makes a cloud computer good for a coding agent?
An agent is not a person at a keyboard, and it is not a one-off script either. It works for hours, waits on its model for much of that time, and comes back to the same repository tomorrow. So we compared eight options on these things:
- **What kind of box it is:** a whole machine, a dev environment or a sandbox.
- **What survives a stop:** files only, or the programs that were running too.
- **What happens when idle:** does it sleep, stop, or keep billing.
- **Root and Docker:** can the agent install system packages and run containers.
- **Full desktop and a browser:** can the agent see and use a screen you can watch.
- **Your agent can start and drive it:** without you clicking anything.
- **Price for the same box,** in the units each provider publishes.
Which isolation sits underneath (container, gVisor, microVM or full VM) matters too; the summary table names it where the provider does.
## How do the eight compare?
| Platform | Kind | Sleeps by itself, keeping programs | Whole disk persists | Root and Docker | 2 vCPU, 4 GB for an hour |
|---|---|---|---|---|---|
| [exe.dev](https://exe.dev/pricing) | Persistent VMs in a monthly pool | Pool billed by the month, busy or idle | Disk | Root | By the month: $35 for a pool of 4 vCPU, 8 GiB |
| [Sprites](https://fly.io/sprites) | Persistent Linux computer | Sleeps, no compute billed | Disk, with checkpoints | Not stated | $0.16 at full use |
| [boxd](https://boxd.sh/) | Hardware-isolated machines | Hibernates after 4 quiet hours | Disk and processes | Not stated | €0.18 for 2 vCPU, 8 GiB |
| shedix | A whole VM per machine, with a full desktop and its own public address | Yes, and you pay only while it works | Yes, with everything installed, signed in and running | Root; Docker installed | $0.09/hr, disk included |
| [Codespaces](https://docs.github.com/en/codespaces/about-codespaces/understanding-the-codespace-lifecycle) | Dev environment | Stops after 30 idle minutes; 12-hour cap | Files; processes stop | Set by the dev container | $0.18 for 2 cores, 8 GB |
| [E2B](https://e2b.dev/pricing) | Sandbox (Firecracker) | Killed or paused at its timeout | A pause keeps memory | From a Docker template | $0.17 |
| [Daytona](https://www.daytona.io/docs/en/sandboxes/) | Sandbox (container or VM) | Stops after 15 idle minutes by default | Files | Docker from a `dind` snapshot | $0.17 |
| [Modal](https://modal.com/docs/guide/sandboxes) | Sandbox (gVisor or VM) | Ends at its timeout, 5 minutes by default | Snapshots, volumes | Docker on the VM runtime | $0.24 |
## How do their prices compare for the same box?
Most of these price each vCPU and GB of memory by the hour, so here everyone billed by the hour is multiplied out to the same boxes, ordered by the 4 vCPU price:
| The same box for one hour | 2 vCPU, 4 GB | 4 vCPU, 8 GB | 8 vCPU, 16 GB |
|---|---|---|---|
| shedix (disk included) | $0.09/hr | $0.21/hr | $0.42/hr |
| [Sprites](https://fly.io/sprites) at full use ($0.0385 per CPU, $0.021875 per GB) | $0.16 | $0.33 | $0.66 |
| [E2B](https://e2b.dev/pricing) ($0.0504 per vCPU, $0.0162 per GiB) | $0.17 | $0.33 | On request |
| [Daytona](https://www.daytona.io/pricing) (same rates) | $0.17 | $0.33 | Above its default limit |
| [Codespaces](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces) (twice the memory) | $0.18 | $0.36 | $0.72 |
| [boxd](https://boxd.sh/pricing) at full use (twice the memory) | €0.18 | €0.36 | €0.70 |
| [Modal](https://modal.com/pricing) ($0.1419 per core of 2 vCPU, $0.024 per GiB) | $0.24 | $0.48 | $0.95 |
Sprites and boxd bill actual use, so their rows are the price with every vCPU busy. exe.dev has no hourly row: its [Personal plan](https://exe.dev/pricing) is $35 a month for a pool of 4 vCPU and 8 GiB shared by up to 50 VMs, billed for the month whatever the hours.
Where shedix comes out: for the same box, 36–44% less than Sprites at full use, 36–47% less than E2B or Daytona and 56–63% less than Modal, with the disk included. An agent's machine rarely works all month, so the working month matters more. For 4 hours on each of 22 workdays, asleep the rest, a 4 vCPU shedix machine costs $24.26 a month (88 hours at $0.21/hr, plus 642 hours asleep at $0.009/hr), against $35 for exe.dev's pool of the same size. Asleep, it keeps everything: the disk, the sign-ins and the running programs. Month-long sums for each option are in [what a coding agent's computer costs](/blog/coding-agent-machine-costs-compared).
## The eight, by kind
### Whole machines
**1. exe.dev.** *Built for:* agents on persistent VMs with HTTPS in front. *Price:* $35 a month for a pool of 4 vCPU and 8 GiB shared by up to 50 VMs ([pricing](https://exe.dev/pricing)). *Strengths:* root over SSH, and a default image that ships Claude Code, Codex and Pi ([docs](https://exe.dev/docs/upgrade-codex)). *Best for:* VMs that stay up all month.
**2. Sprites (Fly.io).** *Built for:* bursty work on a computer that sleeps between bursts. *Price:* usage-metered CPU and memory, hot storage about $0.50 per GB-month, a $1 trial. *Strengths:* not billed for compute while warm or cold, automatic checkpoints, wakes on a request, driven by the `sprite` CLI or its API. *Best for:* short sessions with long gaps.
**3. boxd.** *Built for:* many isolated machines for developers and agents. *Price:* €0.039 per active vCPU-hour, €0.012 per GiB-hour, €30 of credit. *Strengths:* forks a running machine, hibernates with processes intact, self-hostable. *Best for:* branching one machine into many.
**4. shedix.** *Built for:* a real computer in the cloud for your coding agents, started with one tap or by your agent itself: a whole VM with a full desktop, [root and Docker](/use-cases/real-ubuntu), its own public address and every way in. *Price:* $0.09/hr for 2 vCPU, 4 GB RAM, 30 GB disk to $0.84/hr for 16 vCPU, 32 GB RAM, 75 GB disk, by the second and only while it works; asleep from $0.006/hr with everything kept ([pricing](/pricing)). *Strengths:* agent-first, so your agent starts machines, drives them, copies them and moves the conversation it's in onto one, with nothing for you to click; it shares a browser with you on the machine, and finds Claude Code, Codex and VS Code ready; the machine sleeps by itself and a sleeping machine wakes in under a minute; machines run in the United States. *Best for:* agents that work for days, [many at once](/use-cases/many-at-once), reached by SSH with your own keys, VS Code or a terminal in the browser, the desktop, your phone or the agent itself.
Claude Code on a shedix machine's full desktop, opened full screen, next to the browser it shares with you.
### Dev environments
**5. GitHub Codespaces.** *Built for:* a person in VS Code, from a repository's dev container. *Price:* $0.18 an hour for 2 cores and 8 GB, $0.07 per GB-month of storage, a free monthly allowance for personal accounts. *Strengths:* opens from a GitHub repository with the team's set-up. *Best for:* working beside your agent in an editor. More in [Codespaces alternatives for coding agents](/blog/github-codespaces-alternatives-for-coding-agents).
### Sandboxes
**6. E2B.** *Built for:* quick runs of code from an SDK. *Price:* $0.0504 per vCPU-hour, $0.0162 per GiB-hour; Hobby runs a sandbox for at most 1 hour, and Pro is $150 a month for 24-hour sessions. *Strengths:* a pause keeps files and memory with no expiry ([persistence](https://docs.e2b.dev/sandbox/persistence)). *Best for:* running model-written code for users. More in [E2B alternatives](/blog/e2b-alternatives).
**7. Daytona.** *Built for:* long-lived sandboxes with a shell. *Price:* E2B's rates, 5 GiB of disk free, $200 of free compute. *Strengths:* SSH and a web terminal; VM sandboxes can fork and pause. *Best for:* a team's agent platform. More in [Daytona alternatives](/blog/daytona-alternatives).
**8. Modal.** *Built for:* Python and GPU work at scale, with sandboxes beside it. *Price:* $0.1419 per physical core-hour and $0.024 per GiB-hour for sandboxes; $30 a month free on Starter. *Strengths:* very large bursts, GPUs. *Best for:* teams already on Modal. The three sandboxes are set side by side in [Daytona vs E2B vs Modal vs shedix](/blog/daytona-vs-e2b-vs-modal).
## Which kind does your agent need?
| What your agent does | What it needs | Options here |
|---|---|---|
| Works for hours and picks up tomorrow | A disk and programs that last | shedix, exe.dev, Sprites, boxd |
| Runs Docker, a database and system packages | Root on a real kernel | shedix, exe.dev, Modal's VM runtime |
| Runs code your product generates | Fresh sandboxes from an SDK | E2B, Daytona, Modal |
| Several agents at once, one box each | Copies of a set-up machine | shedix, boxd |
| Uses a browser or desktop you can watch | A full desktop | shedix |
| Works beside you in an editor | A dev container | Codespaces |
## Questions people ask
### Do AI coding agents need their own virtual machine?
Not always, but it helps. A separate machine keeps the agent's mistakes off the computer that holds your files and keys, and a whole VM gives it a real kernel for Docker. A sandbox does the same for short runs your code starts.
### What's the difference between a cloud computer and a sandbox?
A sandbox is created by your program, runs a task and is thrown away; a cloud computer is somewhere the agent lives and comes back to. See [sandbox or a whole machine](/blog/sandbox-or-whole-machine-for-coding-agents).
### Is there a free cloud computer for AI agents?
Most have a free start: Daytona's $200 of compute, E2B's $100, boxd's €30, Modal's $30 a month, a monthly Codespaces allowance for personal accounts, a $1 trial on Sprites, and free compute to start on shedix.
### Which ones keep running programs when they sleep?
shedix and boxd keep running processes; E2B does across a pause. A sleeping shedix machine wakes in under a minute. Sprites keep the disk, with checkpoints to restore. Codespaces, Daytona's container sandboxes and Modal keep files, not processes.
### Can the agent start its own cloud computer?
Yes on most: sandboxes through their SDKs, Sprites through the `sprite` CLI or its API, exe.dev over SSH or its API. shedix is made for it: your agent starts machines, drives them, copies them and moves the conversation it's in onto one, with nothing for you to click. `npx skills add shedix-dev/skills` installs the [shedix skill](/skills), and the [guide for agents](/docs/agents) has the rest.
Prices and plans change, so check each provider's own pricing before you choose. [About](/about) and [security](/security) say who runs shedix and how its machines are kept apart.
## What to do next
[Start a shedix machine](/), or install the [shedix skill](/skills) and ask your agent to start one. Your first 12 hours of compute are on us.