# Daytona vs E2B vs Modal vs shedix

> Daytona, E2B, Modal and shedix compared for coding agents on price, what survives a stop, Docker, desktop, run limits and how you get in.

*2026-11-10 · agents, costs, security*

Daytona, E2B and Modal run code in sandboxes your software creates from an SDK; shedix gives your coding agent a whole
computer it lives on. Pick E2B to pause a sandbox with its memory and resume it later, Daytona for long-lived sandboxes
you can SSH into, Modal for huge bursts beside GPU and Python work, and shedix when your agent needs one computer, with a
desktop and its tools, that is still set up tomorrow.

We make shedix. Every other figure comes from each provider's own pages, linked, as of 2026-11-10.

## How do their prices compare?

The three sandbox services price each vCPU and each GB of memory by the hour. shedix sells whole machines, so its row
is the all-in cost per vCPU-hour, with 2 GB of memory per vCPU and the disk included.

| Service | Per vCPU-hour | Per GB of memory per hour | Disk | Plan fee | Free to start |
|---|---|---|---|---|---|
| [shedix](/pricing) | $0.0450 at 2 vCPU, $0.0525 from 4 vCPU, all in | Included | 30–75 GB included | None | 12 hours of compute on us |
| [E2B](https://e2b.dev/pricing) | $0.0504 | $0.0162 (GiB) | Included | Hobby $0; Pro $150/month | $100 of credit, once |
| [Daytona](https://www.daytona.io/pricing) | $0.0504 | $0.0162 (GiB) | 5 GiB free, then per GiB-hour | None | $200 of compute |
| [Modal](https://modal.com/pricing) sandboxes | $0.0710 ($0.1419 per physical core of 2 vCPU) | $0.0240 (GiB) | Volumes and snapshots | Starter $0; Team $250/month | $30 a month on Starter |

All four bill by the second. What that means for the same box running for one hour:

| The same box for one hour | 2 vCPU, 4 GB | 4 vCPU, 8 GB | 8 vCPU, 16 GB | 16 vCPU, 32 GB |
|---|---|---|---|---|
| shedix (disk included) | $0.09/hr (30 GB) | $0.21/hr (45 GB) | $0.42/hr (60 GB) | $0.84/hr (75 GB) |
| E2B | $0.17 | $0.33 | Custom sizes on Pro | Custom sizes on Pro |
| Daytona | $0.17 | $0.33 | $0.66 | $1.32 |
| Modal | $0.24 | $0.48 | $0.95 | $1.90 |

At every size, a shedix machine costs 36–47% less than the same box on E2B or Daytona and 56–63% less than on Modal,
with its disk included. Rivals' figures are their published per-vCPU and per-GB rates multiplied out, as of
2026-11-10. shedix machines run in the United States.

What it takes before an agent works, and what the hourly price covers:

| | Setup to a working agent machine | Included in the price |
|---|---|---|
| shedix | One click, or one line to your agent | CPU, memory, disk, Ubuntu with root and Docker, a desktop, Claude Code, Codex, VS Code in the browser, a phone terminal, previews and SSH |
| E2B | A template with your tools, started from its SDK | CPU, memory and disk; runs past an hour need Pro |
| Daytona | A sandbox created from its SDK | CPU and memory; disk past 5 GiB billed |
| Modal | An image defined in code, started from its SDK | CPU and memory; storage billed separately |

Plan fees matter for small users: E2B's Pro fee buys up to 100 sandboxes at once, and Modal's Team plan is priced for
teams.

## What does each one give an agent?

| | Whole disk persists | Root and Docker | Full desktop | Its own public address | Your agent can start and drive it | Sleeps by itself, keeping programs | What you pay while idle |
|---|---|---|---|---|---|---|---|
| shedix | Yes | Yes, Docker installed | Yes, with a browser the agent shares with you | Yes | Yes, and moves the session it's in onto one | Yes | $0.009/hr for 4 vCPU, 8 GB asleep |
| E2B | Across a pause | Docker from a template | A separate [Desktop sandbox](https://github.com/e2b-dev/desktop) | A URL per port | Yes, from its SDK | Only if set to pause at its timeout | Paused storage, see its pricing page |
| Daytona | Files, once stopped | Yes, with Compose | [VNC](https://www.daytona.io/docs/en/vnc-access/) on default snapshots | Preview URLs per port | Yes, from its SDK | Stops after 15 idle minutes; container memory is not kept | Disk, once stopped |
| Modal | Snapshots and volumes | Docker on its VM runtime | None listed | Tunnels per port | Yes, from its SDK | No; ends at its timeout | Snapshot and volume storage |

## What is each one built for?

- **E2B** is built for an app that runs its model's code in a fresh sandbox, often thousands a day. It uses Firecracker
  microVMs, and its runtime is [open source](https://github.com/e2b-dev/E2B).
- **Daytona** is built for long-lived sandboxes with a shell, created from code. It uses Linux containers by default and
  offers VM sandboxes too.
- **Modal** is built for Python and GPU workloads at scale, with sandboxes beside them; it claims "1M+ sandboxes in under
  a minute" ([sandboxes page](https://modal.com/use-cases/sandboxes)). It uses gVisor by default.
- **shedix** is built as a real computer for coding agents: a whole Linux machine with a desktop, root, Docker and its
  own address, Claude Code, Codex and VS Code ready. Your agent starts and drives it and shares its browser with you,
  and you pay by the second only while it works ([Real Ubuntu](/use-cases/real-ubuntu)).

## What survives when it stops?

- **E2B:** a pause saves the filesystem and memory, running processes included, and keeps them indefinitely; connected
  clients reconnect ([persistence docs](https://docs.e2b.dev/sandbox/persistence)). By default a sandbox is killed at its
  timeout unless set to pause.
- **Daytona:** a stopped container sandbox keeps its files but not memory, and moves to object storage after 7 days
  stopped ([docs](https://www.daytona.io/docs/en/sandboxes/)).
- **Modal:** filesystem snapshots for a later sandbox to start from, and volumes
  ([sandbox guide](https://modal.com/docs/guide/sandboxes)).
- **shedix:** a sleeping machine keeps its whole disk, sign-ins and running programs, and wakes in under a minute where
  it left off ([close the laptop](/use-cases/close-the-laptop)).

## How long can it run?

- **E2B:** 1 hour of continuous runtime on Hobby, 24 hours on Pro; pausing resets the clock.
- **Daytona:** sandboxes "run indefinitely", but stop after 15 minutes of inactivity by default, "even if there are
  internal processes running"; set the interval to 0 for long runs.
- **Modal:** 5 minutes by default, up to 24 hours.
- **shedix:** no limit. A machine stays awake while Claude Code or Codex works on it and sleeps when nobody uses it;
  Keep awake holds it for long jobs.

## Can the agent run Docker?

- **E2B:** from a template with Docker installed ([example](https://docs.e2b.dev/template/examples/docker.md)).
- **Daytona:** yes, including Compose files.
- **Modal:** on its VM runtime, by starting `dockerd` yourself; not on the default gVisor runtime.
- **shedix:** Docker and Compose come installed, with root through sudo and no `--privileged` flag needed.

## How do you get in?

- **E2B:** Python and TypeScript SDKs; SSH through a WebSocket proxy you set up
  ([SSH docs](https://docs.e2b.dev/sandbox/ssh-access)).
- **Daytona:** SDKs, a web terminal, and SSH with a token that expires after 60 minutes by default
  ([SSH docs](https://www.daytona.io/docs/en/ssh-access/)).
- **Modal:** the SDK, with ports reached through tunnels.
- **shedix:** SSH with your own keys, VS Code or a terminal in the browser, the desktop, your phone, or your agent
  through the [shedix skill](/skills) ([guide for agents](/docs/agents)).

## Which one should you pick?

- **E2B** if your app pauses sandboxes mid-task, memory and all, and resumes them later.
- **Daytona** if you want sandboxes that last, with a shell your team can SSH into.
- **Modal** if you already run Python or GPUs on Modal, or need very large bursts.
- **shedix** if the box is for your own coding agent to live on for days, with your repository, tools and sign-ins
  still there each time you come back.

AI answers to this question also name [Vercel Sandbox](https://vercel.com/docs/vercel-sandbox/pricing), which bills CPU
only while it's used and caps a session at 24 hours, and Cloudflare's [Sandbox SDK](https://developers.cloudflare.com/sandbox/),
a container per sandbox behind a Worker. For what each kind of isolation protects, see
[containers, microVMs and full VMs](/blog/container-microvm-or-vm-for-coding-agents); for choosing between a sandbox and a
machine, see [sandbox or a whole machine](/blog/sandbox-or-whole-machine-for-coding-agents).

Prices and limits change, so check each provider's own pricing before you choose.

## What to do next

To try the machine side, [start a shedix machine](/) or run `npx skills add shedix-dev/skills` and ask your agent to
start one. Your first 12 hours of compute are on us.