Modal vs Morph Cloud
Modal runs short-lived gVisor sandboxes on a big serverless AI platform, with GPUs and regions around the world, but each sandbox lasts at most 24 hours. Morph Cloud gives each agent a full VM that can pause, wake on the next request and branch into copies with its memory.
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.
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
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 | Morph Cloud: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | Can't run it | 198th of 367, with limits $2,288 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 hits Modal's 24-hour sandbox limit, while a Morph VM runs until you stop it and a bochka sandbox has no session cap on paid plans. | 196th of 366, with limits $1,924 a month | 235th of 366, with limits $3,014 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 Both fit huge numbers of short code runs: Modal with fast starts and high concurrency, Morph with machines that pause and wake on the next request. | 19th cheapest of 345 $181 a month | 16th cheapest of 345 $154 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 Both fit sandboxes for your users; bochka adds a stopped sandbox that keeps its disk for free and HTTPS on up to 50 ports. | 11th cheapest of 361 $811 a month | 12th cheapest of 361 $905 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 Modal is built for big bursts of short sandboxes, and Morph's memory branching suits rollouts that all start from the same running state. | 5th cheapest of 360 $19,038 a month | 86th of 360, with limits $4,847 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 | 38th cheapest of 364 $675 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 run on Morph and bochka directly, while Modal needs its VM runtime; Morph also sells managed GitHub Actions runners. | 126th cheapest of 377 $1,793 a month | 39th cheapest of 377 $355 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box you return to keeps its whole disk on Morph and bochka, while on Modal only files in a Volume survive the sandbox. | 138th of 368, with limits $23 a month | 85th cheapest of 368 $116 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 ships a ready desktop agent: Modal has a VNC example and Morph a browser-based remote desktop, while bochka has a 60fps desktop, Chromium and a computer use API built in. | 98th of 369, with limits $183 a month | 182nd of 369, with limits $595 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 | 214th of 367, with limits $250 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 | 239th of 346, with limits $234 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 | 154th of 338, with limits $4,750 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 | 214th of 360, with limits $228 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 Morph nor bochka 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 | Morph Cloud | bochka |
|---|---|---|---|
| Isolation | gVisor by default; a VM runtime with its own kernel is available | Full VM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Only with the VM runtime | Yes, including Docker in Docker and local Kubernetes | Yes, in every sandbox, with root and systemd |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | Experimental | Yes, /dev/kvm for Android emulators and VMs |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None | None |
| Pause with memory | No paused state; a finished sandbox is gone, only Volumes keep files | Yes; resume brings back all processes, and a paused VM bills only its snapshot | No; the disk is saved every minute and on stop, and resume boots the machine again |
| Longest session | 24 hours (default 5 minutes) | No limit unless you set a TTL | No cap on paid plans (default TTL 1 h, changeable) |
| Fork and branch | Snapshot the filesystem into an image; memory snapshots are alpha and end the sandbox | Branch a running VM with its memory into many copies in under 250 ms | Fork a running sandbox with its disk without stopping it |
| Wake on request | No | Yes; a paused VM resumes on the next HTTP request, SSH or exec call | No; a stopped sandbox is started by API |
| Desktop, browser, computer use | Not offered; an example shows how to set up VNC yourself | Browser-based remote desktop; you install the browser and any computer use agent | 60fps desktop, Chromium and computer use API built in |
| Coding agents | Examples only; you install and run the agent | You install the agent, then drive it through a tmux API that sends keys | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are environment variables, or you run your own proxy in a sidecar | Responses Proxy for model APIs; other secrets are handed to the machine | Credentials proxy for model providers and any HTTPS API |
| Outbound network rules | Block all, IP-range allowlist, domain allowlist (beta) | No egress allowlist documented | No provider-side allowlist |
| Inbound access | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | Named HTTP services with optional API key auth; SSH through a gateway; no raw TCP | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | Not published | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | Morph Cloud | bochka |
|---|---|---|---|
| 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 | Yes | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | 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 | No | Yes | 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 | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | Yes | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | 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 | Yes | No |
| SSO | Yes | Not published | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the same hpc-sandbox-benchmarks run at 4 vCPU / 8 GB, bochka finished 26.69 Node.js build-and-test runs per second and Modal's default gVisor sandbox 12.79, so bochka did about twice the work. Morph Cloud is not in that benchmark, so there is no comparable CPU score for it. Morph's under 250 ms figure measures snapshot restore 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 measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, a month | Morph Cloud, a month | bochka, 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 | $32 · Developer | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $121 · Team | $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,459 · Scale | $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 | $325 · Scale | $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 | $869 · Scale | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of what you request and what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit and Team is $250 a month with $100 of credit.
Morph Cloud: Morph bills MCUs at $0.05 an hour, where a machine counts 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.
Morph Cloud: bochka charges one hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month, the whole fee becomes usage credit, and a stopped sandbox costs nothing.
Limits in those scenarios
On Modal a sandbox lives at most 24 hours and keeps only files in a Volume, and Docker needs the VM runtime, so the workday, always-on and 50-agent scenarios do not fit its default sandbox. On Morph, disk beyond 16 GiB per vCPU raises the bill, egress prices are not published, and the Developer pool of 64 vCPU holds only 16 machines at 4 vCPU. For 1,000 short jobs at once Morph's Scale plan fits, while Modal's Team tier uses shared vCPUs and bochka's plans queue the starts.
| Scenario | Modal | Morph Cloud | bochka |
|---|---|---|---|
| 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 Modal when
your sandboxes need GPUs, must run outside Europe with outbound rules, or are 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.
- 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. Useful for huge fleets of short jobs: Modal runs up to 5,000 containers at once on its Team plan.
Use Morph Cloud when
your agents need full VMs that branch from one running state with its memory, or sleep between requests and wake on demand.
- Full VMs that keep running. Each Morph machine is a full VM with Docker inside and no session limit, so long agent work is never cut off.
- Branching with memory. Useful for agents that fan out from one running state: Morph copies a VM with its memory in under 250 ms.
- Pause and wake on request. A paused Morph VM bills only its snapshot and wakes on the next HTTP request, SSH or exec call.
Where bochka fits
If your agents work for hours or days, building, testing and using a browser, look at bochka. Every sandbox is a full VM that keeps its disk and costs nothing when stopped, and it arrives with coding agents, a desktop and a key proxy already inside. Pick Modal for GPUs and Morph for memory branching.
A ready desktop and agents you drive from outside
On Modal you set up VNC and the agent yourself; on Morph you install the agent and drive it with keystrokes through tmux. bochka ships a 60fps desktop, Chromium and seven agents you prompt and steer through one API.
Work that is saved without you asking
A Modal sandbox ends within 24 hours and keeps only files in a Volume. On Morph a plain stop deletes the instance unless you pause or snapshot first. bochka saves the disk every minute and on every stop, and a stopped sandbox is free.
Real keys kept outside the machine
On Modal keys sit in environment variables unless you build a sidecar proxy, and Morph's proxy covers model APIs only. bochka's credentials proxy keeps real keys outside for any HTTPS API, so one prompt injection cannot leak them.
Use bochka when your agents work for hours or days and need Docker, a desktop with Chromium, coding agents you drive from outside and keys kept outside the machine, on a fast VM that keeps its disk. Compare it one to one: bochka vs Modal and bochka vs Morph Cloud.
Questions people ask
Is Modal cheaper than Morph Cloud?
It depends on the work. One agent on workdays is $15 a month on Modal against $32 on Morph, but Modal resets files outside a Volume. One always-on agent is $178 on Modal against $121 on Morph, and 50 parallel agents are $2,229 against $1,459. bochka costs $20, $26 and $317 for the same three.
Which is faster, Modal or Morph Cloud?
Morph Cloud has no score in the public benchmark, so there is no fair CPU comparison. Modal's default sandbox did 12.79 runs per second at 4 vCPU / 8 GB, and bochka did 26.69 in the same run.
Can Modal and Morph Cloud run Docker?
Morph runs Docker in every VM, including Docker in Docker and local Kubernetes. Modal runs Docker only on its VM runtime, not its default gVisor sandbox. bochka runs Docker in every sandbox.
Does Morph Cloud have GPUs like Modal?
No. Morph Cloud sells CPU machines, while Modal rents GPUs from T4 to B300. bochka has no GPUs either, so for GPU work Modal is the fit.
Can I pause a sandbox and come back later?
On Morph you can pause a VM with its memory and it wakes on the next request. Modal has no paused state, and a sandbox ends within 24 hours. bochka stops a sandbox for free and resumes it later with its whole disk.
How long can a sandbox run on each?
Modal's maximum is 24 hours, with a 5 minute default. A Morph VM runs until you stop it unless you set a TTL. bochka has no session cap on paid plans.
Try bochka
Install the CLI, then run bochka new.
Product preview