Modal vs exe.dev
Modal gives you short-lived sandboxes inside a serverless AI cloud, with GPUs and huge bursts of parallel jobs, but each one ends within 24 hours. exe.dev rents persistent Linux VMs with root, Docker and SSH that run until you stop them, billed mostly as a reserved pool.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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
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. “19th cheapest of 345” means 18 of the other 344 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 | Modal: price rank | exe.dev: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | Can't run it | 253rd of 367, with limits $3,701 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent runs into Modal's 24-hour sandbox limit, so exe.dev ranks 15th with VMs that never time out, and boat ranks 5th with no session cap on paid plans. | 196th of 366, with limits $1,924 a month | 15th cheapest of 366 $3,833 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 For many tiny code runs Modal fits well with fast starts and high concurrency, while exe.dev's pools and 50-VM limit on Personal are not built for it. | 19th cheapest of 345 $181 a month | 235th of 345, with limits $175 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 Modal fits sandboxes for your users with up to 5,000 containers on Team, exe.dev Personal stops at 50 VMs at once, and boat ranks 1st with stopped sandboxes that keep their disk for free. | 11th cheapest of 361 $811 a month | 257th of 361, with limits $1,226 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 RL rollouts launch many short sandboxes at once, which is what Modal is built for, and Modal ranks 5th here. | 5th cheapest of 360 $19,038 a month | 265th of 360, with limits $5,250 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 | 59th cheapest of 364 $1,244 a month | 283rd of 364, with limits $1,050 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 CI jobs that build Docker images need Modal's VM runtime, exe.dev pools bill whether jobs run or not, and boat ranks 4th with Docker in every sandbox and per-second billing. | 126th cheapest of 377 $1,793 a month | 288th of 377, with limits $504 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev makes a solid 24/7 dev box with root, SSH and a disk that lasts, while Modal sandboxes end within a day; boat adds a desktop in the browser. | 138th of 368, with limits $23 a month | 25th cheapest of 368 $35 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 Computer-use agents need a screen: Modal and exe.dev are both headless, and boat streams a 60fps desktop with Chromium. | 98th of 369, with limits $183 a month | 240th of 369, with limits $1,055 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 | 177th of 367, with limits $136 a month | 130th of 367, with limits $530 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 | 267th of 346, with limits $394 a month | 124th of 346, with limits $278 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 | 223rd of 338, with limits $8,795 a month | 166th of 338, with limits $5,490 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 | Can't run it | 60th of 360, with limits $263 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 Modal has GPUs from T4 to B300, and neither exe.dev nor boat has any, so Modal is the pick for GPU jobs. | 19th cheapest of 98 $1,187 a month | 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 | Modal | exe.dev | boat |
|---|---|---|---|
| Isolation | gVisor by default; a VM runtime with its own kernel since October 2026 | KVM VM with Cloud Hypervisor; you can't choose the kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Only with the VM runtime | Yes, with root and systemd | Yes, in every sandbox, with root and systemd |
| Longest session | 24 hours (default 5 minutes) | No cap; VMs run until you stop them | No cap on paid plans; you set the TTL |
| Stop and resume | No paused state; a finished sandbox is gone, only Volumes keep files | Disk persists; a stopped standalone VM pays nothing for CPU and memory | Stop for free, resume later with the whole disk |
| Snapshots | Filesystem snapshots on demand; memory snapshots in alpha that end the sandbox | None; the disk is streamed to a second server | Every minute while running and on stop; named snapshots as templates |
| Fork | Snapshot the filesystem into an image and boot new sandboxes from it | cp copies a VM's disk and config into a new VM | Fork a running sandbox without stopping it |
| Custom images | Build images in code or pull any linux/amd64 registry image | Boot each VM from your own Docker image | Named snapshots used as templates; no Dockerfile builds |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None | None |
| Desktop and computer use | Not offered; an example shows how to set up VNC yourself | Headless; no desktop or screen streaming | 60fps desktop, Chromium, computer-use and browser-control APIs |
| Coding agents | Examples only; you install the harness yourself | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | Seven harnesses preinstalled, with one API to prompt, steer and stream any of them |
| Secrets | Environment variables, or your own proxy in a sidecar | Integrations inject secrets at the network edge for any HTTP host | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox |
| Inbound traffic | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS proxy for ports 3000 to 9999 and brokered SSH; no public IP or raw TCP | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | Enterprise only | Yes, /dev/kvm on every plan |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | 9 regions in the US, Europe, Asia and Australia | EU only: Germany, Finland, France, with EU data residency |
Every feature Battleships tracks (43)
| Feature | Modal | exe.dev | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Not published | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the same hpc-sandbox-benchmarks run at 4 vCPU / 8 GB on 29 September 2026, boat finished 26.69 Node.js build-and-test runs per second and Modal's default gVisor sandbox 12.79, so boat did about twice the work. exe.dev was not in that run, so there is no comparable CPU measurement for it, and we don't guess how it would score.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. exe.dev has 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 | Modal, a month | exe.dev, 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 | $15 · Starter · with limits | $35 · Personal | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $35 · Personal | $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 | $2,229 · Starter · with limits | $1,848 · Personal | $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 | $792 · Team | $530 · Personal · with limits | $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 | $3,193 · Team · with limits | $1,050 · Personal · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for whichever is higher, the CPU and memory you request or what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit; Team has a monthly fee with $100 of credit, and pinning a region multiplies the price by 1.15x to 1.75x.
exe.dev: exe.dev Personal is a flat monthly pool your VMs share, billed whether they are busy or idle: $35 a month for 4 vCPU / 8 GB. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour and pay nothing for CPU and memory while stopped.
exe.dev: boat bills per second only while a sandbox runs, and the whole monthly plan fee becomes usage credit. A stopped sandbox costs nothing and resumes with its disk.
Limits in those scenarios
On Modal a sandbox lives at most 24 hours and only files in a Volume survive, so the workday, always-on and fleet scenarios don't fully fit, and the 50-agent fleet also needs Docker, which the default sandbox lacks. On exe.dev Personal you get at most 50 VMs at once, so the 300-at-once and 1,000-at-once scenarios don't fit, and its pool bills whether used or not. On boat the limit that bites is start speed: even the top plan queues 1,000 short jobs started at once.
| Scenario | Modal | exe.dev | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users | None that bite |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, outbound traffic rules, or huge bursts of short jobs that finish in minutes.
- GPUs next to your sandboxes. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 on the same platform as its sandboxes.
- Huge bursts of short jobs. Built for many short sandboxes at once, with up to 5,000 containers on the Team plan and fast starts.
- Outbound network rules. Modal can block a sandbox's outbound traffic or allow only chosen IP ranges or domains, which suits running untrusted code.
Use exe.dev when
you want persistent dev boxes or agent VMs that never time out, booted from your own Docker image, in regions outside Europe.
- Machines that never time out. Useful for 24/7 dev boxes and assistants: exe.dev VMs keep their disk and run until you stop them.
- Boot from your own Docker image. exe.dev starts each VM from a container image in about two seconds, so you can point it at your own build.
- Regions and team controls. It runs in nine regions worldwide, and the Work plan covers a whole team with SSO and roles.
Where boat fits
If what you are running is coding or computer-use agents that work for hours, look at boat. It gives each agent a full VM with Docker, a desktop and a disk saved every minute, plus one API to drive agents inside from outside. Pick Modal over it for GPUs or huge bursts, and exe.dev for regions outside Europe.
Work that survives, and can be rolled back
A Modal sandbox ends within 24 hours and its root disk goes with it unless you save files to a Volume. exe.dev keeps the disk but has no snapshots, so one bad agent step can cost a session's work.
A screen agents can use
Modal and exe.dev are both headless, so an agent cannot open the app it built and check it. On either you set up and stream a desktop yourself; boat has a 60fps desktop with Chromium in every sandbox.
Agents driven from outside, keys kept out
Modal offers examples only, and its secrets sit in environment variables. exe.dev takes API prompts only for its own Shelley agent, so Claude Code or Codex means scripting shell sessions yourself.
Use boat when your agents do real work for hours: builds, tests, Docker and a desktop, on a fast VM that saves its disk every minute and that you can drive from outside. Compare it one to one: boat vs Modal and boat vs exe.dev.
Questions people ask
Is Modal cheaper than exe.dev?
It depends on the work. For one agent running 24/7, exe.dev's pool is $35 a month while Modal comes to $178 on Starter and still cuts the sandbox off every 24 hours. For sandboxes for your users, exe.dev Personal is $530 on our table but can't run 300 at once, while Modal fits at $792.
Which is faster, Modal or exe.dev?
There is no comparable measurement for exe.dev. In the hpc-sandbox-benchmarks run at 4 vCPU / 8 GB, Modal's default sandbox did 12.79 runs per second and boat did 26.69.
Can Modal and exe.dev run Docker?
exe.dev VMs run Docker with root and systemd. Modal runs Docker only with its VM runtime, not in the default gVisor sandbox. Every boat sandbox runs Docker with no extra setting.
How long can a session run on Modal and exe.dev?
A Modal sandbox runs 5 minutes by default and 24 hours at most. exe.dev VMs have no time limit and run until you stop them, and boat has no session cap on paid plans.
Do Modal or exe.dev have a desktop for computer use?
No. Both are headless; Modal has an example for setting up VNC yourself. boat gives every sandbox a 60fps desktop with Chromium and APIs for computer use and browser control.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial