Modal vs Modal VM Sandboxes
Modal Sandboxes and Modal VM Sandboxes share one API and one price list. The default gVisor runtime can use GPUs, while the VM runtime gives each sandbox its own Linux kernel so Docker, FUSE and systemd work, but has no GPUs.
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.
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. “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 | Modal VM Sandboxes: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Software factories need Docker, so only the VM runtime fits among the two, and it still loses its root disk within 24 hours; bochka keeps its disk and has a desktop to check the app. | Can't run it | 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 Both Modal runtimes stop a sandbox at 24 hours, while a bochka sandbox has no session cap on paid plans. | 196th of 366, with limits $1,924 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 Short code runs rarely need Docker, so Modal's default gVisor sandbox with its fast starts fits them well. | 19th cheapest of 345 $181 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 Both Modal runtimes cost the same here; users who come back to the same sandbox fit bochka, because a stopped bochka sandbox keeps its disk and costs nothing. | 11th cheapest of 361 $811 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 Huge bursts of short rollouts are what Modal is built for, on either runtime, while bochka's per-plan start limits queue large bursts. | 5th cheapest of 360 $19,038 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 | 59th cheapest of 364 $1,244 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 CI jobs that build Docker images need Modal's VM runtime; every bochka sandbox runs Docker and has /dev/kvm on every plan. | 126th cheapest of 377 $1,793 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 | 138th of 368, with limits $23 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 Modal runtime ships a desktop, so you set up Xvfb and VNC yourself; bochka has a 60fps desktop, Chromium and a computer-use API built in. | 98th of 369, with limits $183 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 | 177th of 367, with limits $136 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 | 267th of 346, with limits $394 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 | 223rd of 338, with limits $8,795 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 | Can't run it | 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 Only Modal's default gVisor runtime has GPUs; Modal VM Sandboxes and bochka have none. | 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 | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Isolation | gVisor, a user-space kernel from Google | VM with its own Linux 7.2 kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Not documented on gVisor | Yes; start dockerd yourself as the entrypoint | Yes, in every sandbox |
| FUSE and kernel features | No | Yes: FUSE, eBPF, systemd and nested cgroups | Yes: own kernel with Docker and systemd |
| Nested virtualization | No | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None; GPU sandboxes need gVisor | None |
| CPU benchmark (4 vCPU / 8 GB) | 12.79 runs/s | 15.54 runs/s | 26.69 runs/s |
| Longest session | 24 hours (default 5 minutes) | 24 hours (default 5 minutes) | No cap on paid plans; you set the time to live |
| Stop and resume | No paused state; only Volumes keep files | No paused state; only Volumes and snapshots keep files | Stop for free, resume later with the whole disk; saved every minute |
| Memory snapshots | Yes, in alpha: snapshotting ends the sandbox, snapshots expire after 7 days | Yes, in alpha, with the same limits, and such a VM cannot mount Volumes | No; resume boots the VM again |
| Fork | Snapshot the filesystem into an image and boot new sandboxes from it | Snapshot the filesystem into an image and boot new sandboxes from it | Fork a running sandbox with its disk, without stopping it |
| Desktop, browser, computer use | Not offered; an example shows how to set up VNC yourself | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps desktop, Chromium and computer-use API built in |
| Coding agents and key proxy | Examples only; secrets are environment variables or your own sidecar proxy | Examples only; secrets are environment variables or your own sidecar proxy | Claude Code, Codex and others preinstalled, driven from outside; real API keys never enter the sandbox |
| Outbound network rules | Block all, IP-range allowlist, domain allowlist (beta) | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Regions | US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x | US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | Modal VM Sandboxes | 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 | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | No | No | 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 | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Not published | Not published | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
The hpc-sandbox-benchmarks Node.js build-and-test loop ran on all three at 4 vCPU / 8 GB in the same run on 29 September 2026. Modal's default gVisor sandbox finished 12.79 runs per second and its VM runtime 15.54, so the VM runtime did about 1.2 times the work. bochka finished 26.69, about twice the gVisor sandbox and about 1.7 times the VM runtime.
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. Modal VM Sandboxes measured on: VM Sandbox, request = size.
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 | Modal VM Sandboxes, 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 | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $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 | $2,229 · Starter · with limits | $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 | $792 · Team | $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 | $3,193 · Team · with limits | $3,193 · Team · 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, until the sandbox is terminated. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region multiplies the price by 1.15x to 1.75x.
Modal VM Sandboxes: VM Sandboxes use the same rates and plans as the gVisor sandboxes, so every scenario costs the same on both. Egress above the free allowance costs $0.04 per GiB on either runtime.
Modal VM Sandboxes: bochka 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
On both Modal runtimes a sandbox lives at most 24 hours and its root disk is gone when it ends, so the workday, always-on and fleet scenarios keep only files you put in a Volume and do not fit. The 50-agent fleet also needs Docker, which the gVisor sandbox lacks and the VM runtime has. The 1,000-job burst is priced on Team with a small CPU request whose extra CPU is shared, on either runtime. On bochka the limit that bites is start speed: even the $2,000 plan starts 90 sandboxes a minute, so 1,000 jobs at once queue.
| Scenario | Modal | Modal VM Sandboxes | 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 | None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, or run short code that needs no Docker, FUSE or nested virtualization.
- GPUs in the sandbox. If your sandbox must run models itself, only the gVisor runtime can attach GPUs, from T4 up to B300.
- The default that just works. For short code runs that need no Docker or FUSE, leaving the runtime at gVisor keeps setup simple.
- Memory snapshots with Volumes. If you need alpha memory snapshots and Volumes together, the gVisor runtime avoids the VM rule that blocks Volumes.
Use Modal VM Sandboxes when
your short-lived agents need Docker, FUSE or systemd, and you want the faster CPU at the same price.
- Docker, FUSE and systemd. If your agent builds images or mounts filesystems, the VM runtime gives it a real Linux kernel to do it.
- Faster CPU for the same price. In the same benchmark run, the VM runtime did 15.54 runs per second against 12.79 for gVisor, at the same rates.
- Nested virtualization on request. Teams on Team or Enterprise can ask Modal for nested virtualization, which the gVisor runtime does not offer.
Where bochka fits
Choosing between Modal's runtimes means trading GPUs for Docker, and both still end every sandbox within 24 hours. If your agents work for hours or days in a machine they come back to, bochka gives every sandbox a full VM with Docker, /dev/kvm and a desktop, on a faster CPU, with a disk that survives free stops. bochka has no GPUs, so GPU work still belongs on Modal.
A disk that survives the day
Both Modal runtimes end a sandbox within 24 hours and drop its root disk, so you write code to snapshot the filesystem or keep files in a Volume. bochka saves the disk every minute, stops for free and has no session cap on paid plans.
Docker and /dev/kvm in every sandbox
On Modal, gVisor has no documented Docker and the VM runtime offers nested virtualization only on Team or Enterprise after you ask. Every bochka sandbox runs Docker and systemd and exposes /dev/kvm for Android emulators on every plan.
A desktop and agents ready to drive
Neither Modal runtime ships a desktop or agent harness, and by default keys sit in environment variables. bochka has a 60fps desktop, Claude Code and Codex driven from outside, and a credentials proxy for any HTTPS API.
Use bochka when your agents work for hours or days in a machine they come back to: Docker, emulators and a desktop, on a faster VM that keeps its disk. Compare it one to one: bochka vs Modal and bochka vs Modal VM Sandboxes.
Questions people ask
Is Modal cheaper than Modal VM Sandboxes?
No, they share one price list, so every scenario costs the same. One always-on agent costs $178 a month on either, against $26 on bochka, and 50 parallel agents cost $2,229 a month on either, against $317 on bochka.
Which is faster, Modal or Modal VM Sandboxes?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, the VM runtime did 15.54 runs per second and the default gVisor runtime 12.79. bochka did 26.69 in the same run.
Can Modal run Docker?
Only with the VM runtime, which you choose with runtime="vm" and then start dockerd yourself. The default gVisor sandbox does not document Docker support. Every bochka sandbox runs Docker with no extra setting.
Can Modal VM Sandboxes use GPUs?
No. Modal says GPU sandboxes are only supported with the gVisor runtime. bochka has no GPUs either.
How long can each run?
Both runtimes default to 5 minutes and stop at 24 hours; for longer work Modal suggests a filesystem snapshot and a new sandbox. bochka has no session cap on paid plans.
Which runtime do I get by default?
If you leave the runtime unset, Modal picks one for you. Set runtime="vm" for VM Sandboxes or runtime="gvisor" for GPUs.
Try bochka
Install the CLI, then run bochka new.
Product preview