bochka vs Modal VM Sandboxes
Both give an agent a real Linux VM with its own kernel, Docker and root. bochka's VM keeps its whole disk, stops for free and runs as long as you want, while Modal's VM Sandboxes are short-lived machines inside a big serverless AI platform.
Where bochka stands out
A VM that keeps its work
A bochka sandbox saves its disk every minute and when it stops. Stopped, it costs nothing, and it comes back days later with every package and file in place, with no session cap on paid plans. A Modal VM Sandbox lasts at most 24 hours and has no paused state.
Desktop, browser and agents ready to go
Every bochka sandbox has a 60fps desktop, Chromium and a computer-use API, plus Claude Code, Codex and other agents you drive from outside through one API. A credentials proxy keeps real API keys out of the sandbox for model providers and any HTTPS API.
More CPU work per hour
In the same public benchmark run at 4 vCPU / 8 GB, bochka finished 26.69 Node.js build-and-test runs per second and Modal's VM runtime finished 15.54. bochka runs on dedicated AMD Ryzen 9 9950X hosts.
The companies and products
bochka
bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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. “3rd cheapest of 367” means 2 of the other 366 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 | bochka: price rank | Modal VM Sandboxes: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker in a real VM, but a Modal VM ends within 24 hours and loses everything outside a Volume, while a bochka sandbox keeps its disk and has a desktop to check the app it built. | 3rd cheapest of 367 $634 a month | 84th of 367, with limits $759 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month needs no session cap, and Modal VM Sandboxes stop at 24 hours. | 5th cheapest of 366 $657 a month | Can't run it |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs fit Modal's model well: fast starts, per-second billing on what you use, and thousands of sandboxes at once on Team. | 186th of 345, with limits $2,000 a month | Can't run it |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Users who come back to the same sandbox fit bochka, because a stopped bochka sandbox keeps its disk and costs nothing while it waits. | Cheapest of 361 $209 a month | Can't run it |
| 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, and bochka's per-plan start limits queue large bursts. | 34th of 360, with limits $2,000 a month | 171st of 360, with limits $16,322 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | Can't run it |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both run Docker builds in a VM; bochka also gives every plan /dev/kvm for Android emulators, which Modal offers only on Team and Enterprise on request. | 4th cheapest of 377 $86 a month | 188th of 377, with limits $1,064 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | Can't run it |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month bochka ships a 60fps desktop, Chromium and a computer-use API; on Modal you install Xvfb, VNC and the browser yourself. | 6th cheapest of 369 $200 a month | Can't run it |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 7th cheapest of 367 $200 a month | Can't run it |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 6th cheapest of 346 $90 a month | Can't run it |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 71st of 338, with limits $1,800 a month | Can't run it |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 294th of 360, with limits $642 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Modal VM Sandboxes have no GPUs (only its gVisor sandboxes do), and bochka has none either. | 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 |
Key features
| Feature | bochka | Modal VM Sandboxes |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | VM with its own Linux kernel on Cloud Hypervisor |
| Docker, systemd, root | Yes, in every sandbox | Yes; start dockerd yourself as the entrypoint |
| CPU benchmark (4 vCPU / 8 GB) | 26.69 runs/s | 15.54 runs/s |
| Nested virtualization | Yes, /dev/kvm on every plan | Team and Enterprise plans only, on request |
| Longest session | No cap on paid plans; you set the time to live | 24 hours (default 5 minutes); continue with a filesystem snapshot |
| Stop and resume | Stop for free, resume later with the whole disk; saved every minute | No paused state; a finished sandbox is gone, only Volumes and snapshots keep files |
| Fork | Fork a running sandbox with its disk | Snapshot the filesystem into an image and boot any number of new sandboxes from it |
| Memory snapshots | No; resume boots the VM again | Yes, in alpha: snapshotting ends the sandbox, snapshots expire after 7 days, no Volumes on VMs |
| Desktop, browser, computer use | 60fps desktop, Chromium and computer-use API built in | Not offered; an example shows how to set up Xvfb and VNC yourself |
| Coding agents and key proxy | Claude Code, Codex and others preinstalled, with a prompt, steer and events API; real API keys never enter the sandbox | Examples only; secrets are environment variables, or you run your own proxy in a sidecar |
| Hosting ports | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist |
| Outbound network rules | Open internet, no provider-side allowlist | Block all, IP-range allowlist, domain allowlist (beta) |
| Regions | EU only: Germany, Finland, France | US, EU and Asia-Pacific plus narrower regions; pinning costs 1.15x to 1.75x |
| GPUs | None | None on the VM runtime; GPU sandboxes need gVisor |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | bochka | Modal VM Sandboxes |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | Yes |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | Yes |
| Memory fork | No | Yes |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Yes |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Not published |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
The hpc-sandbox-benchmarks Node.js build-and-test loop ran on both at 4 vCPU / 8 GB in the same run on 29 September 2026. bochka finished 26.69 runs per second and Modal's VM runtime 15.54, so bochka did about 1.7 times the CPU work in the same time. This measures CPU speed only, not start time.
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.
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 | bochka, a month | Modal VM Sandboxes, 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 | $20 · $20/mo | $15 · Starter · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $178 · Starter · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $2,229 · Starter · with limits |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $792 · Team |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $3,193 · Team · with limits |
bochka: 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.
Modal VM Sandboxes: Modal bills VM Sandboxes at the same rates as its other sandboxes: 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, pinning a region multiplies the price by 1.15x to 1.75x, and egress above the free allowance costs $0.04 per GiB.
Modal VM Sandboxes: Modal prices CPU per physical core and says one core equals two vCPUs. In tests, asking for 4 cores with a matching limit gave the guest 4 CPUs and the measured speed, so the table prices a 4 vCPU sandbox as 4 Modal cores.
Limits in those scenarios
A Modal VM Sandbox lives at most 24 hours and its root disk is gone when it ends, so the workday, always-on and fleet scenarios only keep files you put in a Volume or a snapshot, which is why they do not fit. The 1,000-job burst is priced on Team with a small CPU request that bursts above it, and that extra CPU is shared and not guaranteed. 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 and exceed the daily start limit.
| Scenario | bochka | Modal VM Sandboxes |
|---|---|---|
| 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 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 and memory snapshots. Useful for huge bursts of short jobs: Modal runs 5,000 containers at once on Team, and memory snapshots are in alpha.
- 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.
Use bochka when
your agents work for hours or days in a machine they come back to: installs, builds, tests, Docker, emulators and a desktop, on a faster VM that keeps its disk and never cuts them off.
- A VM that keeps its work. On Modal the VM ends within 24 hours and its root disk goes with it. To keep going you write code that snapshots the filesystem and boots a new sandbox, or keeps files in a Volume.
- Desktop, browser and agents ready to go. Modal's VM gives you the kernel but not the rest: you install VNC, a browser and the agent harness, and by default your real keys sit in environment variables an injected prompt can read.
- More CPU work per hour. Agents spend most of their time waiting on installs, builds and tests. Each of those waits is about 1.7 times as long on a Modal VM Sandbox, and the waiting is billed.
Questions people ask
Is bochka cheaper than Modal VM Sandboxes?
In most of our scenarios, yes: one always-on agent costs $26 a month on bochka against $178 on Modal, and 50 parallel agents cost $317 against $2,229. For one agent on workdays Modal is a little cheaper ($15 against $20), but its files reset between days unless you use a Volume.
What is the difference between Modal Sandboxes and Modal VM Sandboxes?
They share one API and one price list. The default runtime is gVisor, which can use GPUs; runtime="vm" gives a real Linux kernel for Docker, FUSE and systemd, but no GPUs. If you leave the runtime unset, Modal picks one for you.
How long can a Modal VM Sandbox run?
The default timeout is 5 minutes and the maximum is 24 hours. For longer work, Modal suggests taking a filesystem snapshot and starting a new sandbox from it. bochka has no session cap on paid plans.
Can I run Docker and Android emulators in each?
Both run Docker inside the VM. bochka exposes /dev/kvm for Android emulators and VMs on every plan, while Modal offers nested virtualization on Team and Enterprise after you ask support.
Is bochka faster than Modal VM Sandboxes?
On the 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. That is about 1.7 times the CPU work in the same time.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Start a sandbox
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Vercel Sandbox
- bochka vs Blaxel
- bochka vs Runloop
- bochka vs Tensorlake
- bochka vs Cloudflare Sandbox
- bochka vs exe.dev
- bochka vs Agent 37
- bochka vs Oracle Cloud
- bochka vs IONOS Cloud
- E2B vs Modal VM Sandboxes
- Daytona vs Modal VM Sandboxes
- Modal vs Modal VM Sandboxes
- Vercel Sandbox vs Modal VM Sandboxes
- Cloudflare Sandbox vs Modal VM Sandboxes
- Blaxel vs Modal VM Sandboxes
- Runloop vs Modal VM Sandboxes
- Tensorlake vs Modal VM Sandboxes