Blaxel vs Modal VM Sandboxes
Both give each sandbox its own kernel. Blaxel is built to sleep in seconds and wake in milliseconds with its memory intact, while Modal VM Sandboxes are full Linux VMs with Docker and systemd that end within 24 hours.
The companies and products
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
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. “10th cheapest of 367” means 9 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 | Blaxel: price rank | Modal VM Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Blaxel fits a software factory fully, while a Modal VM ends within 24 hours and loses files outside a Volume; boat adds a real disk and /dev/kvm for emulators. | 10th cheapest of 367 $2,373 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 | 12th cheapest of 366 $2,832 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 suit Blaxel best: it sleeps right after a run and resumes in under 25 ms, and boat is not built for this. | 14th cheapest of 345 $144 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 Blaxel's public tiers stop at 200 sandboxes at once, and boat fits 300 users at once on a self-serve plan with disks that stay. | 101st of 361, with limits $926 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 suit Modal, which runs 5,000 containers at once on Team, while Blaxel's public tiers stop at 200 and boat's start limits queue large bursts. | 77th of 360, with limits $4,378 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 | 136th of 364, with limits $704 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, Blaxel at a faster CPU than Modal's VM, and boat gives every plan /dev/kvm for Android emulators. | 57th cheapest of 377 $431 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 | 265th of 368, with limits $114 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 Blaxel runs a desktop and a browser, Modal leaves you to set up Xvfb and VNC yourself, and boat streams a 60fps desktop with a computer-use API. | 14th cheapest of 369 $634 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 | 16th cheapest of 367 $317 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 | 16th cheapest of 346 $215 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 | 147th of 338, with limits $4,292 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 Blaxel fits well with domain, method and path rules on outbound traffic, and boat gives root with raw TCP and nftables inside the VM. | 3rd cheapest of 360 $217 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 Neither fits: Modal's VM runtime has no GPUs (only its gVisor sandboxes do), Blaxel has none, and boat has none either. | Can't run it | 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 | Blaxel | Modal VM Sandboxes | boat |
|---|---|---|---|
| Isolation | Firecracker microVM, own kernel | VM with its own Linux kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | 19.48 runs/s | 15.54 runs/s | 26.69 runs/s |
| Longest session | No forced cap; Tier 0 and Tier 1 delete sandboxes after 7 or 30 days | 24 hours (default 5 minutes); continue with a filesystem snapshot | No cap on paid plans; you set the time to live |
| Idle and resume | Standby seconds after the last connection, wakes in under 25 ms with memory and processes | No paused state; a finished sandbox is gone | Stop for free and keep the disk; resume boots the VM again |
| Disk | Files live in memory (about half the RAM); one block volume can be attached at creation | Root disk is gone when the sandbox ends; only Volumes and snapshots keep files | A real disk that stays, saved every minute and on stop |
| Fork and memory snapshots | Fork with memory and running processes (private preview) | Filesystem snapshots boot new sandboxes; memory snapshots in alpha end the sandbox and expire after 7 days | Fork a running sandbox with its disk; no memory snapshots |
| Docker and systemd | Docker with a Docker-in-sandbox image; no systemd | Docker, FUSE and systemd; start dockerd yourself as the entrypoint | Docker, systemd and root in every sandbox |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan |
| Desktop, browser, computer use | Desktop and browser available | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps desktop, Chromium and a computer-use API built in |
| Coding agents | Claude Code image you drive from its terminal or your own harness | Examples only | Claude Code, Codex and others preinstalled, driven by a prompt, steer and events API |
| Secret proxy | Proxy fills secrets into outbound HTTPS requests (public preview) | Secrets are environment variables, or you run your own proxy in a sidecar | Real keys never enter the sandbox; model providers and any HTTPS API you register |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | Block all, IP-range allowlist, domain allowlist (beta) | Open internet; filter inside the VM with nftables |
| Sandboxes at once | 10, 50 or 200 on self-serve tiers, standby ones included | 100 on Starter, 5,000 on Team | 100 to 2,000 by plan; starts per minute are limited |
| Regions | Oregon, North Virginia, London, Frankfurt | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Blaxel | Modal VM Sandboxes | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Yes | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | 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 | Yes | Yes | No |
| Wake on request | Yes | 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 | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | Yes | Not published | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
All three ran the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB in the same run on September 29, 2026. boat did 26.69 runs per second, Blaxel 19.48 and Modal's VM runtime 15.54, so Blaxel did about 1.25 times Modal's work and boat about 1.7 times. Higher is better, and this measures CPU speed only, not start or wake time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Blaxel measured on: Sandbox (active time, RAM-only pricing, CPU bundled). 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 | Blaxel, a month | Modal VM Sandboxes, a month | boat, 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 | $33 · Pay-as-you-go Tier 1 | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $120 · Pay-as-you-go Tier 1 | $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 | $1,489 · Pay-as-you-go Tier 1 | $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 | $396 · Pay-as-you-go Tier 2 · with limits | $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 | $876 · Pay-as-you-go Tier 2 · with limits | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox is active, with CPU included (8 GB comes with 4 cores). In standby you pay only snapshot storage, and tiers are unlocked by top-ups that go to your wallet as usage credit.
Modal VM Sandboxes: 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: Your plan payment (from $20 a month) is all usage credit, billed per second while a machine runs. 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 on Modal. Blaxel's self-serve tiers stop at 200 sandboxes at once, standby ones included, so 300 users or 1,000 jobs at once need a sales tier. For the 1,000-job burst Modal runs on a small shared CPU request, and boat queues it because it limits how many machines start per minute.
| Scenario | Blaxel | Modal VM Sandboxes | boat |
|---|---|---|---|
| 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 Blaxel when
your sandboxes sit idle most of the time and must wake in milliseconds with their memory, or need provider-side rules on outbound traffic.
- Sleeps in seconds, wakes in milliseconds. For sandboxes that sit idle most of the time: one sleeps seconds after the last connection and wakes in under 25 ms.
- No 24-hour cutoff. A Blaxel sandbox has no forced session length, and from Tier 2 it can wait in standby for good.
- A faster CPU than Modal's VM. On the same benchmark at 4 vCPU and 8 GB, Blaxel ran 19.48 runs per second and Modal's VM runtime 15.54.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that finish within a day, need a full kernel or regions outside the US and Europe, or already run models on Modal.
- A full Linux kernel. For workloads that need systemd, FUSE or Docker in a real VM, with nested virtualization on Team on request.
- Very large bursts. For huge waves of short jobs: Modal runs 5,000 containers at once on Team and more on Enterprise.
- Regions and one AI platform. Modal runs in the US, EU and Asia-Pacific, next to its inference and training on one account.
Where boat fits
If your agents work for hours or days on the same machine, look at boat. It is a whole Linux VM with a real disk that stays, /dev/kvm, a 60fps desktop and coding agents you drive from outside, on a faster CPU than both.
A disk that stays, with no time limit
Blaxel keeps files in memory, about half the RAM, unless you attach a volume at creation. A Modal VM ends within 24 hours and takes its root disk with it, so you write snapshot code. boat saves the disk every minute.
A whole Linux machine
Without /dev/kvm an Android emulator or a VM will not start. Blaxel's Firecracker guests never get it, and Modal gives it only on Team and Enterprise after you ask support. boat has it on every plan, with systemd.
More work per hour
Agents spend most of their time on installs, builds and tests. Measured at 4 vCPU and 8 GB, each of those waits about 1.4 times as long on Blaxel and 1.7 times as long on Modal's VM, and the waiting is billed.
Use boat when your agents work for hours or days on a machine they come back to: builds, tests, Docker and emulators on a faster VM with a real disk, a desktop and agents built in. Compare it one to one: boat vs Blaxel and boat vs Modal VM Sandboxes.
Questions people ask
Is Blaxel cheaper than Modal VM Sandboxes?
For one always-on agent Blaxel costs $120 a month against $178 on Modal, and 50 parallel agents cost $1,489 against $2,229. For one agent on workdays Modal is cheaper ($15 against $33), but its files reset between days unless you use a Volume. On boat those cost $26, $317 and $20 a month.
Which is faster, Blaxel or Modal VM Sandboxes?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU and 8 GB, Blaxel did 19.48 runs per second and Modal's VM runtime 15.54. boat did 26.69 in the same run.
Can Blaxel and Modal VM Sandboxes run Docker?
Both can. Blaxel uses a Docker-in-sandbox image, and on Modal you start dockerd yourself as the entrypoint. For Android emulators you need /dev/kvm: Blaxel has none, Modal offers it on Team and Enterprise on request, and boat has it on every plan.
How long can a sandbox run on each?
A Modal VM Sandbox defaults to 5 minutes and lasts at most 24 hours. Blaxel has no forced session length, though Tier 0 and Tier 1 delete sandboxes after 7 or 30 days. boat has no session cap on paid plans.
Do they keep memory when idle?
Blaxel saves memory and running processes in standby and resumes them in under 25 ms. Modal has no paused state; its memory snapshots are alpha and end the sandbox. boat keeps the disk and reboots on resume.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial