Beam vs Modal VM Sandboxes
Beam's sandboxes are fast gVisor containers on a GPU platform, can run until you stop them, and sit next to a separate line of CPU VMs. Modal VM Sandboxes give every sandbox its own Linux kernel on Cloud Hypervisor, but each one ends within 24 hours.
The companies and products
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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. “8th cheapest of 345” means 7 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 | Beam: 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 A software factory needs Docker, systemd and a disk that lasts; Beam sandboxes have no systemd, Modal VMs end within 24 hours, and bochka gives every sandbox all three. | 69th of 367, with limits $551 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 agent that lives on its machine all month can run on Beam with no time cap, but not on Modal VM Sandboxes, which stop at 24 hours; bochka keeps the disk across free stops. | 115th of 366, with limits $651 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 Beam fits short code runs well: sandboxes start in a second or two, bill per second and go away when their timer ends. | 8th cheapest of 345 $117 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 Beam fits user sandboxes well with quick containers and 1,000 at once on Team; bochka gives each user a full VM whose disk waits for free while they are away. | 3rd cheapest of 361 $290 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, with 5,000 containers at once on Team, while bochka's start limits queue large bursts. | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 Both run Docker builds, but Android or VM image builds need /dev/kvm, which bochka has on every plan and Modal only on Team and Enterprise on request. | 12th cheapest of 377 $171 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 | 13th cheapest of 368 $21 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 Beam nor Modal ships a desktop or browser, so you would set up Xvfb and VNC yourself; bochka has a 60fps desktop with Chromium built in. | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 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 Beam has GPU sandboxes up to H100, H200 and B200; Modal VM Sandboxes have no GPUs (only its gVisor sandboxes do), and bochka is CPU only. | Cheapest of 98 $458 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 | Beam | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Isolation | gVisor container by default; Beam VMs are a separate CPU microVM product | VM with its own Linux kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and systemd | Docker with docker_enabled; systemd only in Beam VMs, not in sandboxes | Docker, systemd and root; you start dockerd yourself | Docker, systemd and root in every sandbox, like a normal Ubuntu server |
| Nested virtualization | Not documented | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan for Android emulators and VMs |
| CPU benchmark (4 vCPU / 8 GB) | No result | 15.54 runs/s | 26.69 runs/s |
| Longest session | No published cap; default 10 minutes, or run until you terminate it | 24 hours (default 5 minutes); continue from a filesystem snapshot | No cap on paid plans; you set the time to live |
| Disk between runs | A sandbox keeps files only in a saved image or a volume; a Beam VM keeps a 50 GiB root disk while stopped | No paused state; only Volumes and snapshots keep files | Disk saved every minute and on stop; a stopped sandbox keeps it for free |
| Snapshots and fork | Memory snapshot of a running sandbox with its processes, restored into new sandboxes | Filesystem snapshots; memory snapshots in alpha that end the sandbox and expire after 7 days | Fork a running sandbox with its disk |
| GPUs | GPU sandboxes and serverless GPUs, from T4 up to H100, H200 and B200 | None on the VM runtime; GPU sandboxes need gVisor | No, CPU only |
| Desktop and browser | No desktop or browser product | Not offered; an example shows how to set up Xvfb and VNC yourself | Linux desktop streamed at 60fps with Chromium and a computer-use API |
| Inbound access | Public HTTPS URL per exposed port with no built-in auth; no raw TCP | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS on up to 50 ports, token-protected by default, plus raw TCP and a dedicated IPv4 or IPv6 |
| Outbound rules | Block all, or allow up to 10 CIDR ranges, changeable while running | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Coding agents and API keys | No agents preinstalled; secrets are environment variables in the sandbox | Examples only; secrets are environment variables, or you run your own proxy in a sidecar | Seven agents preinstalled with a prompt, steer and events API; a credentials proxy keeps real keys out |
| Regions | US only; no other region is listed | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | EU only: Germany, Finland, France |
| Self-hosting | Beta9 runtime is AGPL-3.0 and free to self-host; bring your own cloud for a fee | No | No |
Every feature Battleships tracks (43)
| Feature | Beam | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | 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) | 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 | No | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | 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 | Yes | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | Not published | Yes |
| Audit logs | Not published | Yes | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the StarSling hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Modal's VM runtime did 15.54, so bochka did about 1.7 times the CPU work in the same time. Beam has no result on that test, so we cannot say how its CPU speed compares. Beam's own guide says its sandboxes cold-boot in 1 to 3 seconds.
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. Beam 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 | Beam, 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 | $5 · 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 | $22 · Developer | $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 | $410 · Team | $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 | $191 · 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 | $259 · Team | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
Beam: Beam sandboxes bill per second for each CPU core you request (one core is two vCPU) and each GiB of RAM, until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee, Team is $89 a month plus usage with no credit, and there are no egress fees.
Modal VM Sandboxes: Modal bills VM Sandboxes by the second for the higher of what 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, pinning a region costs 1.15x to 1.75x, and egress above the allowance is $0.04 per GiB.
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 is 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 files only in a Volume or a snapshot, so the workday, always-on and 50-agent scenarios do not fit, and its 1,000-job burst runs on shared CPU above the request. Beam fits every scenario, but it publishes no price for extra disk, so no disk cost is counted for it, and its Developer plan allows 30 CPU containers at once, so 50 agents need Team. On bochka, 1,000 jobs at once queue on start limits even on the $2,000 plan.
| Scenario | Beam | 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Beam when
your agents need GPUs, when you want sandboxes and serverless GPU endpoints in one platform, when a sandbox must run with no time cap in the US, or when you must self-host.
- GPUs on the same platform. For agents that need a GPU, Beam has GPU sandboxes and serverless GPUs from RTX 4090 up to H100 and B200.
- No time cap on sandboxes. For long jobs, a Beam sandbox can run until you terminate it, and Beam VMs keep their root disk while stopped.
- Open source and your own cloud. For teams that must self-host, Beam's Beta9 runtime is AGPL-3.0, and it can also run in your own cloud for a fee.
Use Modal VM Sandboxes when
each job needs a real Linux kernel and finishes within a day, when you run huge bursts of short jobs, need regions outside Europe or strict outbound rules, or already run models on Modal.
- A real kernel in every sandbox. For tools that need a real Linux kernel, every Modal VM Sandbox runs Docker, FUSE and systemd in its own VM.
- Regions and outbound rules. For teams outside Europe or with strict network rules, Modal runs in the US, EU and Asia-Pacific and can allow only chosen domains.
- Very large bursts. For huge bursts of short jobs, Modal runs 5,000 containers at once on Team, next to its inference and training.
Where bochka fits
If your agents work for hours or days and come back to the same machine, look at bochka. Each bochka sandbox is a full VM with /dev/kvm, Docker and systemd, keeps its disk across free stops, has no session cap on paid plans, and comes with a desktop, coding agents and a credentials proxy.
A machine that keeps its work
A Beam sandbox loses its files when its timer ends unless you save an image or use a volume, and a Modal VM ends within 24 hours with its root disk. bochka saves the disk every minute and keeps it while stopped.
A full VM with /dev/kvm on every plan
Beam sandboxes are gVisor containers with no systemd, and neither Beam product documents /dev/kvm. Modal offers nested virtualization only on its paid Team and Enterprise plans, after asking support. Every bochka sandbox has /dev/kvm for Android emulators and VMs.
Desktop, agents and keys built in
On Beam and Modal you install the agent harness, Xvfb, VNC and a browser yourself, and real API keys sit in environment variables an injected prompt can read. bochka ships a 60fps desktop, seven agents and a credentials proxy.
Use bochka when your agents do real work over hours or days: installs, builds, Docker, emulators and a browser on a faster full VM whose disk is still there the next time it starts. Compare it one to one: bochka vs Beam and bochka vs Modal VM Sandboxes.
Questions people ask
Is Beam cheaper than Modal VM Sandboxes?
In every scenario on this page, yes. One agent that never stops costs $22 a month on Beam against $178 on Modal, and 50 parallel agents cost $410 against $2,229. Beam's numbers count no disk cost, because Beam publishes no price for extra disk.
Which is faster, Beam or Modal VM Sandboxes?
We cannot compare their CPU speed: Modal's VM runtime did 15.54 runs per second on the hpc-sandbox-benchmarks CPU test, and Beam has no result on it. bochka did 26.69 on the same test. Beam's guide says its sandboxes cold-boot in 1 to 3 seconds.
Is a Beam sandbox a VM like Modal's?
Not by default. Beam's sandboxes are containers using gVisor, with an opt-in microVM mode for CPU sandboxes, and Beam sells separate CPU VMs. Every Modal VM Sandbox, and every bochka sandbox, is a VM with its own Linux kernel.
Can Beam and Modal VM Sandboxes run Docker?
Yes. Beam runs Docker in a sandbox with docker_enabled, and Modal VM Sandboxes run Docker once you start dockerd. Only Modal also has systemd in the sandbox; bochka has Docker, systemd and /dev/kvm in every sandbox.
How long can each sandbox run?
A Beam sandbox defaults to 10 minutes but can run until you terminate it, with no published cap. A Modal VM Sandbox defaults to 5 minutes and stops at 24 hours at most. bochka has no session cap on paid plans.
Do Beam or Modal VM Sandboxes have GPUs?
Beam does, with GPU sandboxes and serverless GPUs up to H100, H200 and B200. Modal VM Sandboxes do not; only Modal's gVisor sandboxes can use GPUs. bochka is CPU only.
Try bochka
Install the CLI, then run bochka new.
Product preview