Modal vs Blaxel
Modal runs short-lived gVisor sandboxes inside a big AI compute platform, with GPUs and regions around the world. Blaxel gives each sandbox a Firecracker microVM with its own kernel that sleeps seconds after you disconnect and wakes in under 25 ms 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.
Blaxel
Blaxel is a San Francisco company that runs cloud infrastructure for AI agents, and since September 2026 it is part of Baseten.
You get sandboxes, batch jobs, MCP server hosting and a model gateway. Each sandbox is a Firecracker microVM with its own kernel that drops to standby when nothing is connected and resumes in under 25 ms with its memory and running processes. It is built for agent products that start many sandboxes and want them asleep most of the time.
- Headquarters
- San Francisco, founded 2024
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 | Blaxel: 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 | 10th cheapest of 367 $2,373 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant hits Modal's 24-hour session cap, while Blaxel sleeps it between requests and bochka keeps it on a full VM with no session cap on paid plans. | 196th of 366, with limits $1,924 a month | 12th cheapest of 366 $2,832 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 short code runs well: Blaxel ranks 14th by sleeping right after each run, and Modal ranks 19th with fast starts and big concurrency. | 19th cheapest of 345 $181 a month | 14th cheapest of 345 $144 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 Modal's Team plan fits 300 users at once and ranks 11th, Blaxel's public tiers stop at 200 at once, and bochka ranks 1st because a stopped sandbox keeps its disk and costs nothing. | 11th cheapest of 361 $811 a month | 101st of 361, with limits $926 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 ranks 5th for RL rollouts because it is built for huge bursts of short sandboxes, while Blaxel's public tiers stop at 200 at once. | 5th cheapest of 360 $19,038 a month | 77th of 360, with limits $4,378 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 | 136th of 364, with limits $704 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 Blaxel with its Docker image but need Modal's separate VM runtime, while bochka runs Docker in every sandbox. | 126th cheapest of 377 $1,793 a month | 57th cheapest of 377 $431 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither is a plain machine you SSH into and leave on: Modal sandboxes end within 24 hours and Blaxel has no native SSH, while bochka is. | 138th of 368, with limits $23 a month | 265th of 368, with limits $114 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 Blaxel ships a desktop and browser and ranks 14th, Modal has no desktop of its own, and bochka ranks 6th with a 60fps desktop and a computer-use API. | 98th of 369, with limits $183 a month | 14th cheapest of 369 $634 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 | 16th cheapest of 367 $317 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 | 16th cheapest of 346 $215 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 | 147th of 338, with limits $4,292 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 | 3rd cheapest of 360 $217 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 has GPUs, from T4 to B300, so it is the only one of the three that runs GPU eval 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 | Blaxel | bochka |
|---|---|---|---|
| Isolation | gVisor user-space kernel by default; a VM runtime is sold separately as Modal VM Sandboxes | Firecracker microVM with its own kernel | Full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Not in the default sandbox; only with the VM runtime | Yes, with a Docker-in-sandbox image | Yes, in every sandbox |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | No: Firecracker guests do not get /dev/kvm | Yes: /dev/kvm, so Android emulators and VMs run inside |
| Longest session | 24 hours (default 5 minutes) | No session cap; lower tiers delete sandboxes after 7 or 30 days | No cap on paid plans (default TTL 1 h, changeable) |
| Stop and resume | No paused state; a finished sandbox is gone, only Volumes keep files | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | Stop keeps the whole disk and costs nothing; resume boots the VM again |
| Disk | Root disk wiped when the sandbox ends; Volumes keep files | Files live in memory (about half the RAM); one block volume can be attached at creation | A real disk that stays, saved every minute and on stop |
| Fork and snapshots | Filesystem snapshots into images; memory snapshots in alpha end the sandbox and expire after 7 days | Fork with memory and running processes (private preview) | Fork a running sandbox without stopping it (disk, not memory) |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None | None |
| Desktop, browser, computer use | Not offered; an example shows how to set up VNC yourself | Desktop, browser and computer use available | 60fps desktop, Chromium and computer-use API built in |
| SSH and inbound traffic | SSH; encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | Preview URL per port, public or token-protected; no native SSH, raw TCP or public IP | Real SSH; HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | Domain allow and deny lists, method and path rules, static egress IPs | Open internet; filter inside the VM with nftables |
| Secrets and API keys | Secrets are environment variables, or you run your own proxy in a sidecar | Proxy fills secrets into outbound HTTPS requests; sandbox never sees them (public preview) | Real keys never enter the sandbox; model providers and any HTTPS API you register |
| Coding agents | Examples only; you bring the harness | Claude Code image you drive from its terminal or your own harness | Claude Code, Codex, OpenCode, pi and more preinstalled, driven from outside by a prompt, steer and events API |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | Oregon, North Virginia, London, Frankfurt | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | Blaxel | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | No | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | 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 | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | Not published | Yes | Yes |
| Audit logs | Yes | Not published | 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 | Yes | Yes |
Performance
All three ran the same hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB on September 29, 2026. Blaxel did 19.48 runs per second and Modal's default gVisor sandbox 12.79, so Blaxel did about 1.5 times the work of Modal. bochka did 26.69, about 1.4 times Blaxel and twice Modal, on dedicated AMD Ryzen 9 9950X hosts.
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. Blaxel measured on: Sandbox (active time, RAM-only pricing, CPU bundled).
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 | Blaxel, 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 | $33 · Pay-as-you-go Tier 1 | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $120 · Pay-as-you-go Tier 1 | $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,489 · Pay-as-you-go Tier 1 | $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 | $396 · Pay-as-you-go Tier 2 · with limits | $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 | $876 · Pay-as-you-go Tier 2 · 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, and an idle sandbox pays until it 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.
Blaxel: Blaxel charges for allocated RAM per second while a sandbox is active, meaning a connection is open, with CPU included. In standby you pay only snapshot storage, and volumes are billed on their full size.
Blaxel: 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.
Limits in those scenarios
On Modal, a sandbox lives at most 24 hours and its root disk is wiped when it ends, so the workday, always-on and 50-agent scenarios do not fit, and the fleet also needs Docker, which the default sandbox lacks. Blaxel fits those three but its self-serve tiers stop at 200 sandboxes at once, standby ones included, so 300 users at once and 1,000 jobs at once need a sales tier. Modal's Team plan fits the 300 users, and none of the three fits 1,000 short jobs at once on a public plan: bochka queues starts above 90 a minute.
| Scenario | Modal | Blaxel | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | 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 in Asia-Pacific, or come in huge bursts of short jobs that finish well within a day.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 next to its sandboxes.
- Very large bursts. Useful for RL rollouts and huge batches: Modal's Team plan runs up to 5,000 containers at once.
- Regions around the world. Modal runs in the US, the EU and Asia-Pacific, and you can pin a sandbox to a region.
Use Blaxel when
your sandboxes sit idle most of the time and must wake in milliseconds with their memory, or need fine-grained outbound rules.
- Sleeps and wakes with its memory. Useful if sandboxes sit idle most of the time: one sleeps seconds after disconnecting and wakes in under 25 ms.
- A real kernel with Docker. Each sandbox is a Firecracker microVM, so Docker runs with its Docker image and no separate runtime.
- Fine outbound rules. Blaxel can limit a sandbox to chosen domains, down to methods and paths, and give it static egress IPs.
Where bochka fits
If your agents work for hours or days on installs, builds, tests and Docker, look at bochka. Modal cuts sessions at 24 hours and wipes the root disk, and Blaxel keeps files in memory and has no /dev/kvm. bochka gives each agent a whole Linux machine with a real disk and the fastest CPU of the three.
A disk that stays, with no session cap
On Modal an agent's root disk goes when the sandbox ends, within 24 hours, unless you write code to save to a Volume. On Blaxel files sit in memory, about half the RAM, unless you attach a volume at creation.
A whole Linux machine
bochka has /dev/kvm, systemd, real SSH and Docker in every sandbox. Modal needs its separate VM runtime for Docker, and Blaxel guests get no /dev/kvm, so Android emulators and VMs do not start there.
Faster builds and agents built in
bochka ran 26.69 benchmark runs per second, against 19.48 for Blaxel and 12.79 for Modal. Claude Code and Codex come installed with an API to drive them from outside, where both others leave the harness to you.
Use bochka when your agents work for hours or days: builds, tests, Docker and emulators on a whole Linux machine with a real disk, the fastest CPU of the three and agents built in. Compare it one to one: bochka vs Modal and bochka vs Blaxel.
Questions people ask
Is Modal cheaper than Blaxel?
It depends on the shape. For one coding agent on workdays Modal is $15 against $33 on Blaxel, but its files reset between days. For one agent that never stops Blaxel is $120 a month against $178 on Modal, and for 50 agents in parallel $1,489 against $2,229. bochka costs $20, $26 and $317 for those three.
Which is faster, Modal or Blaxel?
In the same benchmark at 4 vCPU and 8 GB, Blaxel did 19.48 runs per second and Modal's default sandbox 12.79, about 1.5 times the work. bochka did 26.69 in the same run.
Can Modal or Blaxel run Docker?
Blaxel runs Docker with its Docker-in-sandbox image. Modal's default gVisor sandbox does not; you need its VM runtime, which Battleships tracks as a separate card. Every bochka sandbox runs Docker with no extra setting.
How long can a sandbox run on Modal and on Blaxel?
A Modal sandbox runs 5 minutes by default and 24 hours at most. Blaxel has no session cap, but its lower tiers delete sandboxes after 7 or 30 days. bochka has no session cap on paid plans.
Does Modal or Blaxel have GPUs?
Modal has GPUs from T4 to B300, with 10 at once on Starter and 50 on Team. Blaxel and bochka have none.
Where do Modal and Blaxel run?
Modal runs in the US, the EU and Asia-Pacific. Blaxel runs in Oregon, North Virginia, London and Frankfurt. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview