Disclosure: I work at Upstash, which makes Upstash Box. Every price below comes from the vendor's own pricing page or docs (November 2026), so you can check all of it.

The rate cards look close: one vCPU with 2 GB lists at $0.08 to $0.17 an hour. The bills aren't, because each provider meters something different while your agent sits waiting on the model. So I priced one concrete workload on seven sandboxes:

  • A coding-agent hour: Claude Code or Codex running inside a 2 vCPU, 4 GB sandbox for an hour. Most of that hour goes to waiting on the model: the CPU does 10 vCPU-minutes of work, and about 1.5 GB of memory is in use.
  • The same for 100 users: each user gets their own sandbox and one such hour a day, for a month (3,000 hours).
Sandbox One coding-agent hour 100 users, one month
Upstash Box $0.017 $50
Fly.io Sprites $0.041 $122
Modal $0.064 $192
Vercel Sandbox $0.106 $318
E2B $0.166 $497
Daytona $0.166 $497
Blaxel $0.166 $497

Monthly bill for 100 per-user coding agents, one 1-hour session per user per day on a 2 vCPU, 4 GB sandbox: Upstash Box $50, Fly.io Sprites $122, Modal $192, Vercel Sandbox $318, E2B $497, Daytona $497, Blaxel $497

What decides the bill

  • Wall clock or actual use. E2B and Daytona bill every vCPU and GB for every second the sandbox runs, waiting included. Box, Sprites and Vercel bill CPU only when it's busy. Modal bills the higher of what you request or what you use.
  • Memory. Vercel bills provisioned memory for every running minute, which is 80% of its bill here. Sprites and Modal bill the memory actually in use. Box doesn't bill memory.
  • Where the agent loop runs. Blaxel suspends about 15 seconds after the last connection. If your agent runs on your server and only calls the sandbox to run code, Blaxel bills each call plus those 15 seconds instead of the whole hour.
  • Busy CPU flips the order. At 100% of both vCPUs, Box's default meter costs $0.20 an hour, more than E2B or Daytona at $0.1656. For always-busy work, a keep-alive Box costs a flat $0.0111 an hour ($8 a month).

The seven at a glance

Sandbox Price (2 vCPU, 4 GB) Billed while the agent waits Between sessions Longest session
Upstash Box $0.10 per busy vCPU-hour, memory free Nothing Auto-pauses with files kept, ~0.6 s resume No cap
E2B $0.1656/hour, per second CPU and memory Pause keeps memory and files, ~1 s resume 24 h on Pro, 1 h free
Daytona $0.1656/hour, per second CPU and memory Stops after 15 min idle by default No cap
Modal $0.142 per physical core-hour + $0.024/GiB-hour Memory in use, small CPU floor No pause; filesystem snapshots 24 h
Fly.io Sprites $0.0385/CPU-hour + $0.021875/GB-hour, actual use Memory in use Sleeps when idle, 100 GB disk kept No cap
Blaxel $0.0414/GB-hour while awake, CPU included Memory Standby keeps memory, under 25 ms resume No cap
Vercel Sandbox $0.128/busy CPU-hour + $0.0212/GB-hour Memory Snapshot on stop, resumes on the next call 24 h on Pro, 45 min free

So which one

  • Running untrusted code from your users: E2B. Each sandbox is its own Firecracker microVM, the Python and JS SDKs are mature, and its Code Interpreter SDK runs model-written code in one call. Sessions over an hour need the $150/month Pro plan, and the meter runs while the agent waits.
  • Long-running agent sessions and one sandbox per user: Upstash Box. You pay for the CPU your agent burns, so a box waiting on the model or sitting idle between a user's visits costs only its disk ($0.10/GB-month). Each box is a persistent computer that keeps its files, packages and git history between sessions, with no session cap. It also does the agent plumbing you'd otherwise write:
    • box.agent.run() runs Claude Code, Codex, OpenCode or Cursor in the box with your own model key, or plugs in your own agent
    • git clone, commit, push and createPR, cron schedules that run a command or an agent prompt, and a managed Chromium
    • Attach Headers adds API keys outside the box, so code inside can't read them, plus a network allowlist you can change on a running box
  • GPU work: Modal. Sandboxes can take a GPU and bill per second. Daytona also rents GPUs by the hour.
  • A persistent dev machine with a big disk: Fly.io Sprites. A hardware-isolated VM with a 100 GB disk, checkpoints in about a second, and its own HTTPS URL.
  • Resuming in milliseconds between short tasks: Blaxel. Standby keeps memory and running processes, and resumes in under 25 ms.
  • Windows or macOS desktops for computer-use agents: Daytona. It also has Linux VMs, GPUs and $200 of free compute. If you picked it to self-host, its open-source GitHub repo is now archived; BYOC is an Enterprise option.
  • Apps already on Vercel: Vercel Sandbox. Firecracker isolation, persistent by default, billed on your Vercel account.

Before you pick

Boot time matters less than vendors suggest: cloning a repo and installing packages takes longer than any of these starts. What matters more is what the agent can reach. Keep API keys out of environment variables (the code your model writes can read them), lock outbound traffic to the domains the agent needs, and run a day of your real agent before you trust any estimate, including mine.

How I compared them

  • Prices: list prices on 2026-11-18, pay-as-you-go, default US region. Plan fees, free credits and model tokens are left out.
  • The hour: 2 vCPU and 4 GB where you pick a size, awake for the full hour, 10 vCPU-minutes of CPU (8% use; Vercel's own examples assume 10% "reflecting time spent waiting for LLM calls"), 1.5 GB of memory in use (Sprites' own Claude Code example).
  • Modal: default request (0.125 core, 128 MiB), CPU as 5 minutes on one physical core (2 vCPU) and 55 minutes under the floor.
  • Sprites: actual CPU and memory plus 2 GB of hot storage while awake.
  • Blaxel: charged for the full hour, assuming the agent runs inside it and keeps it awake.
  • Storage between sessions: left out of the monthly figure. Rates per GB-month: about $0.02 for Sprites' cold storage, $0.08 for Daytona's stopped disk (first 5 GiB free) and Vercel snapshots, $0.10 on Box, $0.20 for Blaxel's memory-and-disk snapshots.
  • Box resume time: my own measurement from Europe, pause then resume to the first command, three runs.