exe.dev vs smol machines
exe.dev rents long-lived Linux VMs you reach over SSH, from a reserved pool in one of nine regions. smol machines runs open-source microVMs that bill for the CPU and memory they actually use, wake on the next command and can branch a running machine with its memory.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “15th cheapest of 366” means 14 of the other 365 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | exe.dev: price rank | smol machines: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month boat ranks 3rd for a software factory with snapshots, a desktop and agents driven by API; smol machines ranks 73rd and exe.dev 253rd. | 253rd of 367, with limits $3,701 a month | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB exe.dev ranks 15th for always-on assistants because a flat pool suits a VM that never stops; smol machines bills every running hour, and boat ranks 5th with a desktop and browser built in. | 15th cheapest of 366 $3,833 a month | 148th of 366, with limits $1,038 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month smol machines ranks 12th for short code runs, with a one-minute minimum and wake on the next command; exe.dev and boat are built for longer sessions. | 235th of 345, with limits $175 a month | 12th cheapest of 345 $140 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month smol machines ranks 7th for sandboxes you hand to your users, and boat ranks 1st; exe.dev's Personal plan stops at 50 VMs at once. | 257th of 361, with limits $1,226 a month | 7th cheapest of 361 $531 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month smol machines can branch a running machine with its memory and processes, so many rollouts start from one prepared state; exe.dev copies only a VM's disk. | 265th of 360, with limits $5,250 a month | 111th of 360, with limits $6,978 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 283rd of 364, with limits $1,050 a month | 36th cheapest of 364 $670 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month smol machines ranks 66th for CI and exe.dev 288th, since exe.dev pools bill whether jobs run or not; boat ranks 4th and adds /dev/kvm for Android builds. | 288th of 377, with limits $504 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev ranks 25th as a 24/7 dev box with SSH and a lasting disk, while smol machines has no SSH; boat ranks 18th and adds a desktop in the browser. | 25th cheapest of 368 $35 a month | 216th of 368, with limits $29 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither exe.dev nor smol machines has a hosted desktop, so computer-use agents need a screen stack you build yourself; boat ranks 6th with a 60fps desktop. | 240th of 369, with limits $1,055 a month | 90th of 369, with limits $156 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 130th of 367, with limits $530 a month | 176th of 367, with limits $136 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 124th of 346, with limits $278 a month | 241st of 346, with limits $242 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 166th of 338, with limits $5,490 a month | 148th of 338, with limits $4,344 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 60th of 360, with limits $263 a month | 252nd of 360, with limits $377 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | exe.dev | smol machines | boat |
|---|---|---|---|
| Isolation | KVM VM with Cloud Hypervisor; you can't choose the kernel | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Shell access | SSH, root and systemd | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Saved state | Disk persists and is streamed to a second server; no snapshots | Filesystem survives a stop, memory paths are emptied; stopped disk keeps billing; cloud snapshot routes return 501 | Snapshots every minute while running and on stop; a stopped sandbox costs nothing and keeps its disk |
| Fork | cp copies a VM's disk and config into a new VM | Branch a running machine with its memory and processes | Fork a running sandbox with its disk; named snapshots as templates |
| Wake on request | No; you start a stopped VM yourself | A command or terminal starts a stopped machine; idle apps wake on the next request | No; a stopped sandbox is started by API |
| Custom images | Boot from your own Docker image | Boot from container images, with registry images in amd64 and arm64 | Templates from named snapshots; no Dockerfile or OCI images |
| Nested virtualization | Enterprise only | Not exposed in the cloud create API; a local smolvm flag only | Yes, /dev/kvm on every plan for Android emulators and VMs |
| Desktop and browser | Headless; no desktop or screen streaming | No hosted desktop; a guide shows running your own Chromium inside a machine | 60fps Linux desktop with Chromium, computer use and browser control |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, with one API to prompt, steer and stream events |
| Keeping API keys out of the sandbox | Integrations inject secrets at the network edge for any HTTP host, S3 and GitHub | Cloud secrets are environment variables the guest can read | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Inbound traffic | HTTPS proxy for ports 3000 to 9999, one of them public; no public IP or raw TCP | Up to 16 published ports through a returned URL or an authenticated connect route; no dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Open internet, no provider-side allowlist | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Regions | 9 regions in the US, Europe, Asia and Australia | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | Bring your own cloud on AWS or GCP on Enterprise | Open-source smolvm runs on your laptop or your own servers | No; hosted only |
Every feature Battleships tracks (43)
| Feature | exe.dev | smol machines | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | No | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither exe.dev nor smol machines has been run on the StarSling hpc-sandbox-benchmarks CPU test, so there is no comparable CPU measurement for either. boat did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms for smolvm, which measures start time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev and smol machines have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | exe.dev, a month | smol machines, a month | boat, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $35 · Personal | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $35 · Personal | $93 · Standard | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $1,848 · Personal | $1,139 · Pro | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $530 · Personal · with limits | $465 · Startup | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $1,050 · Personal · with limits | $1,389 · Startup | $2,000 · $2000/mo · with limits |
exe.dev: exe.dev Personal is a flat monthly pool your VMs share, billed the same whether they are busy or idle; a 4 vCPU / 8 GiB pool is $35 a month. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
smol machines: smol cloud charges $0.04 for every hour a machine runs, plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.
smol machines: Plans start at $20 a month, and the whole fee is usage credit. Sandboxes bill per second while they run, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal allows 50 VMs at once, so 300 user sandboxes or 1,000 short jobs at once don't fit there. smol machines caps the machines you hold by plan: 20 on Standard, 100 on Pro and 1,000 on Startup, with stopped machines still holding a slot, so 50 parallel agents need Pro and a 1,000-job burst needs Startup. boat's limit that bites is starts: on the $2,000 plan, starts above 90 a minute are queued, so the 1,000-job burst does not fit.
| Scenario | exe.dev | smol machines | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel | None that bite | None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use exe.dev when
you want a long-lived dev box you SSH into, booted from your own Docker image, in a region near your users, with SSO and roles for the team.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- A dev box you SSH into. For developers who live in a terminal: each VM takes SSH, has root and systemd, and boots from your own Docker image.
- Team controls and an MCP server. Its Work plan covers a whole team with SSO and roles, and an MCP server lets tools like Claude Code control VMs.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, bills that follow real CPU use, or branches of a running machine with its memory.
- Open source, laptop to your own servers. Teams that want the same VM on a laptop, in a hosted cloud and on their own servers get one open-source engine.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes, and wake stopped machines on the next command.
- Outbound allowlists and arm64. Teams that must limit which hosts a machine reaches, or need arm64 images, get both on smol cloud.
Where boat fits
If the VMs you are comparing will run coding or computer-use agents for hours, look at boat too. Like both, it gives each agent a real VM with its own kernel, and it adds a desktop, a snapshot every minute, /dev/kvm on every plan and one API to drive agents inside from outside.
A screen your agents can use
exe.dev VMs are headless and smol cloud has no hosted desktop, so on either you build, package and stream a desktop and browser yourself before a computer-use agent can click anything.
State saved every minute
exe.dev has no snapshots to roll back to, and smol cloud's snapshot routes return 501, so one bad agent step can cost a session's work. boat snapshots every minute and on stop.
Drive agents inside from outside
On exe.dev only Shelley takes prompts through the API, and on smol cloud you write the harness on top of exec calls. boat lets you prompt, steer and stream seven preinstalled agents through one API.
Use boat when your agents do real work for hours: builds, Docker, emulators, a desktop and a browser, with state saved every minute and one API to drive agents inside from outside. Compare it one to one: boat vs exe.dev and boat vs smol machines.
Questions people ask
Is exe.dev cheaper than smol machines?
It depends on how long machines run. For one agent that never stops, exe.dev's flat pool is $35 a month against $93 on smol machines. For 50 agents in parallel on 8-hour sessions, smol machines is $1,139 a month against $1,848 on exe.dev, because it bills only while machines run.
Which is faster, exe.dev or smol machines?
We can't say: neither has been measured on the StarSling CPU benchmark we use. boat scored 26.69 runs per second on it at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms, which is start time, not CPU speed.
Can exe.dev and smol machines run Docker?
Yes, both run Docker inside the VM. exe.dev can also boot each VM from your own Docker image, and smol's guide says Docker data must live on the machine's ext4 disk. Neither exposes /dev/kvm on regular plans; boat does on every plan.
Does smol machines have SSH like exe.dev?
No. smol cloud gives you a command API, sessions and a WebSocket terminal capped at one hour per connection. exe.dev and boat both take SSH.
Can I self-host exe.dev or smol machines?
smol machines' engine, smolvm, is open source and runs on your laptop or your own servers. exe.dev is hosted, with bring your own cloud on AWS or GCP on its Enterprise plan. boat is hosted only.
Do either of them have a desktop for computer-use agents?
No. exe.dev VMs are headless, and smol machines only documents running your own Chromium inside a machine. boat streams a 60fps Linux desktop with Chromium, computer use and browser control.
Try boat
Install the CLI, then run boat new.
7-day free trial