Morph Cloud vs Modal VM Sandboxes
Both give an agent a full Linux VM with its own kernel, root and Docker. Morph Cloud keeps a machine as long as you want and can pause, branch and wake it with its memory, while Modal's VM Sandboxes are short-lived machines, at most 24 hours each, inside a big serverless AI platform.
The companies and products
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on 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. “16th cheapest of 345” means 15 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 | Morph Cloud: price rank | Modal VM Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker in a full VM, but a Modal VM ends within 24 hours and loses files outside a Volume, while a Morph VM runs until you stop it; boat adds preinstalled coding agents and keeps its disk across free stops. | 198th of 367, with limits $2,288 a month | 84th of 367, with limits $759 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month fits Morph, which has no session cap, but not Modal, whose VMs stop at 24 hours; boat adds a desktop, agents and a credentials proxy. | 235th of 366, with limits $3,014 a month | Can't run it | 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 Morph fits short code runs well: a machine can pause with its memory, cost almost nothing while paused, and wake on the next request. | 16th cheapest of 345 $154 a month | Can't run it | 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 Morph can pause each user's machine and wake it on the next request; on Modal a returning user's files survive only in a Volume or snapshot, and on boat a stopped sandbox keeps its disk for free. | 12th cheapest of 361 $905 a month | Can't run it | 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 Morph's memory branching suits rollouts that start from one running state; Modal's memory snapshots are in alpha and end the original sandbox. | 86th of 360, with limits $4,847 a month | 171st of 360, with limits $16,322 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 | 38th cheapest of 364 $675 a month | Can't run it | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Morph also sells managed GitHub Actions runners; on Modal and boat you run builds in your own VM, and boat gives /dev/kvm on every plan. | 39th cheapest of 377 $355 a month | 188th of 377, with limits $1,064 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 85th cheapest of 368 $116 a month | Can't run it | 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 Morph nor Modal ships a ready desktop agent: Morph has browser remote access where you install the browser, Modal's example has you set up Xvfb and VNC, and boat ships a 60fps desktop with Chromium and a computer use API. | 182nd of 369, with limits $595 a month | Can't run it | 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 | 214th of 367, with limits $250 a month | Can't run it | 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 | 239th of 346, with limits $234 a month | Can't run it | 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 | 154th of 338, with limits $4,750 a month | Can't run it | 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 | 214th of 360, with limits $228 a month | 294th of 360, with limits $642 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 | Morph Cloud | Modal VM Sandboxes | boat |
|---|---|---|---|
| Isolation | Full VM with its own kernel | VM with its own Linux 7.2 kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and systemd | Yes, including Docker in Docker and local Kubernetes | Yes; you start dockerd yourself as the entrypoint | Yes, in every sandbox |
| Nested virtualization | Experimental | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan for Android emulators and VMs |
| CPU benchmark (4 vCPU / 8 GB) | Not measured | 15.54 runs/s | 26.69 runs/s |
| Longest session | No cap; a time to live is optional | 24 hours (default 5 minutes); continue from a filesystem snapshot | No cap on paid plans; you set the time to live |
| Pause with memory and wake on request | Yes; a paused VM keeps every process, bills only its snapshot and wakes on the next HTTP request, SSH or exec call | No paused state; a finished sandbox is gone | No; a stopped sandbox keeps its disk and is started again by API |
| Saving work automatically | Saved when you pause or snapshot; a plain stop deletes the instance | Only Volumes and snapshots keep files | Disk saved every minute and on every stop; a stopped sandbox is free |
| Fork a running machine | Branch with its memory into many copies in under 250 ms | Filesystem snapshot to an image you boot many times; memory snapshots in alpha end the original | Fork a running sandbox with its disk |
| Desktop, browser, computer use | Browser-based remote desktop; you install the browser and any computer use agent | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps desktop with Chromium and a computer use API |
| Coding agents | You install the agent and drive it through a tmux API that sends keys and reads the screen | Examples only | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Responses Proxy for model APIs; other secrets go into the machine | Secrets are environment variables, or you run your own proxy in a sidecar | Credentials proxy for model providers and any HTTPS API |
| Inbound access | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Outbound network rules | No egress allowlist documented | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Regions | Not published | US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | Modal VM Sandboxes | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | No | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | Not published | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Not published | Yes | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, run on 29 September 2026, boat did 26.69 runs per second and Modal's VM runtime 15.54, so boat did about 1.7 times the CPU work in the same time. There is no comparable measurement for Morph Cloud: it is not in that run. Morph says it restores a snapshot in under 250 ms, 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. Modal VM Sandboxes measured on: VM Sandbox, request = size. Morph Cloud 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 | Morph Cloud, a month | Modal VM Sandboxes, 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 | $32 · Developer | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · Team | $178 · Starter · with limits | $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,459 · Scale | $2,229 · Starter · with limits | $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 | $325 · Scale | $792 · Team | $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 | $869 · Scale | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
Morph Cloud: Morph bills MCUs at $0.05 each: per hour, a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, and a paused VM bills only its snapshot storage.
Modal VM Sandboxes: Modal bills by the second for the higher of the CPU and memory you request or what you use, until the sandbox ends. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and egress above the free allowance costs $0.04 per GiB.
Modal VM Sandboxes: boat charges one hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit; a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
A Modal VM Sandbox lives at most 24 hours and keeps only files in a Volume or snapshot, so the workday, always-on and 50-agent scenarios do not fit there, and its 1,000-job burst runs on shared vCPUs that other tenants can slow. Morph fits every scenario, but its price rises with more than 16 GiB of disk per vCPU, egress prices are not published, and the Developer pool of 64 vCPU holds only 16 machines at 4 vCPU. boat's limit is start speed: at 1,000 short jobs at once even the $2,000 plan queues starts, while Morph Scale fits.
| Scenario | Morph Cloud | Modal VM Sandboxes | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| 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 Morph Cloud when
your agents branch from one running state with its memory, sleep between requests and wake on demand, or run for days without a session cap.
- Memory branching. For agents that fan out from one running state: Morph branches a live VM with its memory into many copies in under 250 ms.
- Pause, wake on request, no session cap. For machines that sleep between requests: a paused VM keeps its processes, bills only its snapshot and wakes on the next call.
- Managed CI runners and other guests. Morph also sells managed GitHub Actions runners and a shared filesystem, and lists experimental Windows and macOS (x86) guests.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that finish within a day, need regions outside Europe or strict outbound rules, or already run your models on Modal.
- Regions and outbound rules. Modal runs in the US, EU and Asia-Pacific, and can block a sandbox's outbound traffic or allow only chosen domains.
- Very large bursts. For huge bursts of short jobs that finish within a day: Modal runs 5,000 containers at once on Team.
- One platform with inference and training. Useful if you already serve or train models on Modal: sandboxes, GPUs and models sit on one account and one bill.
Where boat fits
Morph Cloud and Modal VM Sandboxes both hand you a VM and leave the agent setup to you. If your agents work for hours or days in a machine they come back to, boat gives them a VM that keeps its disk, with coding agents, a desktop and a credentials proxy already inside. Look elsewhere if you need memory branching, regions outside Europe or 1,000 jobs starting at once.
Work that survives a stop
A plain stop on Morph deletes the instance, so you pause it and keep paying for the snapshot. A Modal VM ends within 24 hours and its root disk goes with it unless files sit in a Volume. boat saves the disk every minute and stops for free.
Agents, desktop and keys already inside
On Morph you drive agents by tmux keystrokes, and its proxy covers model APIs only. On Modal agents are examples, keys sit in environment variables, and you build Xvfb and VNC yourself. boat ships agents with an API, a 60fps desktop and a proxy for any HTTPS API.
Faster CPU and /dev/kvm on every plan
In the same benchmark run boat did 26.69 runs per second and Modal's VM runtime 15.54, so builds wait about 1.7 times longer on Modal; Morph was not measured. Nested virtualization is experimental on Morph and on request on Modal.
Use boat when your agents work for hours or days in a machine they come back to: coding agents you drive from outside, a 60fps desktop, real keys kept out of the sandbox, and a faster VM that keeps its disk. Compare it one to one: boat vs Morph Cloud and boat vs Modal VM Sandboxes.
Questions people ask
Is Morph Cloud cheaper than Modal VM Sandboxes?
In most of our scenarios, yes: one always-on agent costs $121 a month on Morph against $178 on Modal, and 50 parallel agents cost $1,459 against $2,229. For one agent on workdays Modal is cheaper ($15 against $32), but its files reset between days unless you use a Volume.
Which is faster, Morph Cloud or Modal VM Sandboxes?
Morph Cloud is not in the hpc-sandbox-benchmarks run, so there is no fair CPU comparison. Modal's VM runtime did 15.54 runs per second at 4 vCPU / 8 GB, and boat did 26.69 in the same run.
How long can a sandbox run on each?
A Morph VM has no session cap: it runs until you stop it or a time to live you set runs out. A Modal VM Sandbox defaults to 5 minutes and lasts 24 hours at most, after which you continue from a filesystem snapshot. boat has no session cap on paid plans.
Can Morph Cloud and Modal run Docker and nested virtualization?
Both run Docker inside a full VM; on Modal you start dockerd yourself. Morph lists nested virtualization as experimental, and Modal offers it on Team and Enterprise after you ask support. boat exposes /dev/kvm on every plan.
Can both snapshot a running VM with its memory?
Morph can snapshot and branch a running VM with its memory in under 250 ms, and each copy keeps running. Modal's memory snapshots are in alpha: taking one ends the sandbox and it expires after 7 days. boat forks a running sandbox with its disk, not its memory.
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