# What a coding agent's computer costs, compared hour for hour

> A 4 vCPU, 8 GB agent machine priced across sandboxes, devboxes, VPSes and shedix as of 2026-11-02, with idle rules, what survives a stop, and caps.

*2026-11-02 · costs, agents, remote-dev*

When Granda's [phone setup](https://granda.org/en/2026/01/02/claude-code-on-the-go/) for coding agents reached Hacker News, one reply asked why it needed a [$210-a-month VM](https://news.ycombinator.com/item?id=46494846). Price comes up whenever someone shows a setup like it. Comparison tables exist, such as Superagent's [sandbox benchmark](https://www.superagent.sh/blog/ai-code-sandbox-benchmark-2026) and Daniel Botha's [comparison for Fly.io](https://fly.io/learn/sprites-vs-e2b-vs-modal-vs-daytona/). Both price sandboxes for running code, and the second comes from a vendor in the table.

This post prices a computer for an agent: one size, used three ways. Our [earlier post](/blog/cost-of-an-always-on-agent-box) covered shedix's prices on their own; this one puts them next to everyone else's.

## How we compared

- **One size:** 4 vCPU and 8 GB of memory, or the nearest each service sells. It's boxes.dev's standard box and Daytona's default ceiling.
- **Three uses:** one 6-hour job; 8 hours on 22 workdays, which is 176 hours; and always on, 730 hours (24 × 365 ÷ 12).
- **List prices** from each service's own pages on 2026-11-02, before tax. Free allowances are left out, though they're worth having: Codespaces gives free personal accounts 30 hours a month on a 4-core machine, E2B $100 of credit once, Daytona $200, Sprites $30, and boxes.dev a 20-hour trial.

shedix is in a private beta and charges nothing yet, so its figures are its published rates.

## The rates

As of 2026-11-02:

| Service | What you get | How it's billed | Price |
|---|---|---|---|
| shedix M | VM: 4 vCPU, 8 GB, 45 GB disk | Per hour while it runs | $0.16/hr |
| [exe.dev](https://exe.dev/pricing) Personal | Pool of 4 vCPU and 8 GiB, shared by up to 50 VMs | Monthly, while the pool exists | $35/month |
| exe.dev standalone VM | 4 vCPU, 8 GiB | By the second while it runs | $0.21/hr |
| [Sprites](https://fly.io/sprites) (Fly.io) | Linux machine, billed for CPU and memory in use | Hourly, on actual use | $0.0385 per CPU-hour + $0.021875 per GB-hour |
| [boxes.dev](https://boxes.dev/pricing) | 4 vCPU, 8 GB, 100 GB disk | Hours included, per user | $19 (50 h), $99 (250 h) or $249 (600 h) a month, then $0.60/hr |
| [E2B](https://e2b.dev/pricing) Pro | Sandbox: 4 vCPU, 8 GiB | By the second | $0.33/hr plus $150/month |
| [Daytona](https://www.daytona.io/pricing) | Sandbox: 4 vCPU, 8 GiB | By the second | $0.33/hr |
| [GitHub Codespaces](https://docs.github.com/en/billing/concepts/product-billing/github-codespaces) | 4 cores, 16 GB | Per hour, plus storage | $0.36/hr + $0.07 per GB-month |
| [Hetzner](https://www.hetzner.com/cloud/regular-performance/) CPX32 | VPS: 4 vCPU, 8 GB, 160 GB, Germany or Finland | Hourly up to a monthly cap, until deleted | €0.0577/hr, at most €35.99/month |
| [DigitalOcean](https://www.digitalocean.com/pricing/droplets) Basic | VPS: 4 vCPU, 8 GiB, 160 GiB | By the second up to a monthly cap, until destroyed | $0.07143/hr, at most $48/month |

E2B and Daytona charge the same rates: $0.0504 per vCPU-hour and $0.0162 per GiB-hour, so 4 × $0.0504 + 8 × $0.0162 = $0.3312 an hour. E2B's free Hobby plan only runs its default size, so this size needs Pro. Codespaces has no 4-core, 8 GB machine; its [2-core machine has 8 GB](https://github.com/pricing/calculator?feature=codespaces) for $0.18/hr. Hetzner's price includes an IPv4 address and excludes VAT. The totals below leave out disk, which Codespaces ($0.07 per GB-month), Sprites (about $0.50 per GB-month while hot) and Daytona ($0.000108 per GiB-hour past the first 5 GiB) charge separately.

## Three ways of using it

| Service | One 6-hour job | 8 hours on 22 workdays | Always on |
|---|---|---|---|
| shedix M | $0.96 | $28.16 | $116.80 |
| exe.dev pool | $35 | $35 | $35 |
| Sprites, fully busy | $1.97 | $57.90 | $240.17 |
| boxes.dev | $19 | $94.60 | $327 |
| E2B Pro | $151.99 | $208.29 | $391.78 |
| Daytona | $1.99 | $58.29 | $241.78 |
| Codespaces | $2.16 | $63.36 | Not possible |
| Hetzner CPX32 | €0.35 | €35.99 | €35.99 |
| DigitalOcean | $0.43 | $48 | $48 |

How the rows work out:

- **Sprites** bills only for the CPU and memory in use, so "fully busy" (4 × $0.0385 + 8 × $0.021875 = $0.329 an hour) is a ceiling. Fly.io's own example, a 4-hour Claude Code session averaging 30% of 2 CPUs and 1.5 GB, comes to $0.23. For an agent that mostly waits on the model, Sprites can cost less than any flat hourly rate here.
- **boxes.dev:** the job fits in Starter's 50 hours. A working month is Starter plus 126 hours at $0.60, and always on is Max plus 130 hours at $0.60.
- **E2B:** the $150 Pro fee dominates. It buys up to 100 sandboxes running at once, a plan sized for products that start many.
- **Codespaces** stops every codespace after 12 hours, [even while you use it](https://docs.github.com/en/codespaces/about-codespaces/understanding-the-codespace-lifecycle).
- **VPSes** cost the hourly rate only if you delete the server when the job is done. Kept, they cost the monthly price, running or not: Hetzner bills until you delete a server, and DigitalOcean's docs say a [powered-off droplet is still billable](https://docs.digitalocean.com/reference/doctl/reference/compute/droplet-action/power-off/).

## When the meter stops

The table assumes you pay for the hours you use. Idle rules decide whether you do:

- **shedix** stops a machine after 60 minutes unused. Use means an SSH session, an open terminal or VS Code tab, an agent writing its conversation, a quarter of a core busy, or 1 MB of network in 30 seconds. An agent waiting for your answer doesn't count, and Keep awake turns sleep off for a machine.
- **Sprites** stops billing within seconds of no activity. A request in flight, an open TCP connection, a task or output to a session counts as activity; output from a detached tmux session doesn't, per its pricing page.
- **Daytona** stops a sandbox after 15 minutes of inactivity by default, and its [docs](https://www.daytona.io/docs/en/sandboxes/) say it does so even with processes running inside. Set the interval to 0 for long agent runs.
- **Codespaces** stops after 30 idle minutes by default, adjustable from 5 to 240. Typing and terminal output reset the clock.
- **boxes.dev** says idle boxes sleep automatically and sleeping boxes are free. Its pricing page gives no timeout.
- **E2B** ends a sandbox when its timeout runs out, unless you've set it to pause instead.
- **exe.dev's pools and the VPSes** never stop the meter: you pay while the pool or server exists.

## What survives a stop

- **shedix:** the disk, with everything installed and signed in. Running programs end. A stopped machine starts again in under a minute, where a new one takes about 60 to 110 seconds. Disk beyond the 45 GB included is $0.10 per GB a month.
- **Sprites:** a 100 GB disk that survives sleep, with automatic checkpoints you can restore.
- **E2B:** [pausing](https://docs.e2b.dev/sandbox/persistence) keeps the filesystem and memory, running processes included, with no expiry. Clients connected to services inside are disconnected.
- **Daytona:** a stopped container sandbox keeps its files but not its memory, and moves to object storage after 7 days stopped, by default.
- **Codespaces:** stopped codespaces are [deleted automatically](https://docs.github.com/en/codespaces/setting-your-user-preferences/configuring-automatic-deletion-of-your-codespaces), after at most 30 days.
- **exe.dev:** a stopped VM keeps its disk, and a stopped standalone VM isn't billed for CPU or memory.

## Caps and limits

- **Session length:** E2B runs a sandbox for at most 1 hour on Hobby and 24 hours on Pro, and pausing resets the clock. A codespace stops after 12 hours.
- **Size:** Daytona's default limit per sandbox is 4 vCPU, 8 GB and 10 GB of disk, so this comparison sits at its ceiling.
- **How many at once:** boxes.dev's plans allow 4, 10 or 20 awake devboxes. exe.dev's Personal pool holds 50 VMs.
- **What's inside:** a shedix machine is a whole VM with root through sudo, and its stacks other than Plain include Docker. A codespace is a Docker container on a VM.

## The machine next to the model bill

Set the machine next to the agent's own plan. Claude's [plans](https://claude.com/pricing) are $20 a month for Pro, $100 for Max and $200 for Ultra. A working month on a shedix M, $28.16, is a little more than Pro, and Granda's VM at about $210 a month is more than Ultra. The machine bill matters most when it's left on: the always-on column runs from $35 to $391.78.

So for one machine that never stops, a VPS or an exe.dev pool is cheapest. For a working day, an hourly machine at shedix's rate costs less than either VPS and stops charging by the hour when you're away. For bursty agent work, Sprites' usage billing can undercut everything. For many short sandboxes started from code, E2B and Daytona are built for the job.

If you want to see what an hourly machine costs for your own pattern, the [pricing page](/pricing) has every size, and our post on [home servers, VPSes and cloud VMs](/blog/home-server-vps-or-cloud-vm-for-coding-agents) weighs the choice beyond price.