Blaxel vs Docker Cloud Sandboxes
Both give each sandbox its own microVM with its own kernel. Blaxel puts a sandbox to sleep seconds after the last connection and wakes it in under 25 ms, with no session cap, while Docker Cloud Sandboxes runs the same sbx microVM you use on your laptop, for up to 24 hours at a time.
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
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory runs many agents for days, which fits Blaxel but not Docker's 24-hour sessions and 10 at once; boat adds /dev/kvm and a real disk. | 10th cheapest of 367 $2,373 a month | 280th of 367, with limits $4,928 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month fits Blaxel, which sleeps when idle, while a Docker session ends 24 hours after creation. | 12th cheapest of 366 $2,832 a month | 276th of 366, with limits $5,110 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 Blaxel is the better pick for short code runs, since it sleeps right away and wakes in milliseconds; Docker's small per-second sandboxes come next, and boat is not built for this. | 14th cheapest of 345 $144 a month | 119th of 345, with limits $233 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 Neither fits 300 users at once on a self-serve plan: Blaxel's public tiers stop at 200 and Docker's default is 10, while boat runs them on a self-serve plan. | 101st of 361, with limits $926 a month | 136th of 361, with limits $1,628 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 | 77th of 360, with limits $4,378 a month | 114th of 360, with limits $7,000 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 Running many evals at once hits Blaxel's tier caps and Docker's 10 at once, while boat starts a fresh VM per task from a named snapshot. | 136th of 364, with limits $704 a month | 167th of 364, with limits $1,400 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 that builds Android apps or VM images needs /dev/kvm, which boat exposes and neither Blaxel's Firecracker guests nor Docker's documented sandboxes offer. | 57th cheapest of 377 $431 a month | 172nd of 377, with limits $672 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 dev box: Blaxel has no native SSH and Docker ends sessions after 24 hours, while boat is a machine you SSH into and leave on. | 265th of 368, with limits $114 a month | 127th of 368, with limits $204 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 runs a desktop and a browser while Docker's cloud sandboxes are terminal only, and boat streams a 60fps desktop you can embed in your app. | 14th cheapest of 369 $634 a month | 268th of 369, with limits $1,400 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 | 16th cheapest of 367 $317 a month | 277th of 367, with limits $700 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 | 16th cheapest of 346 $215 a month | 262nd of 346, with limits $350 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 | 147th of 338, with limits $4,292 a month | 190th of 338, with limits $7,000 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 | 3rd cheapest of 360 $217 a month | 248th of 360, with limits $350 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 | 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 | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel; Docker through a Docker-in-sandbox image | MicroVM with its own Linux kernel and its own Docker Engine; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts; Docker with root and systemd |
| Session length | No forced session cap; Tier 0 and Tier 1 delete sandboxes after 7 or 30 days | 1 hour by default, at most 24 hours from creation | No cap on paid plans; you set the time to live |
| Sandboxes at once | 10, 50 or 200 by self-serve tier, standby sandboxes included; more through sales | 10 by default; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans, self-serve |
| Idle and resume | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | Stop keeps memory and files and resume picks up where it left off; snapshots go after 7 days of non-use | Disk saved every minute and on stop, a stopped sandbox costs nothing; resume boots the machine again |
| Fork | Fork with memory and running processes (private preview) | Snapshot a running sandbox with disk or disk and memory, then restore it as a new sandbox | Fork a running sandbox with its disk |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | Not documented | Yes: /dev/kvm, so Android emulators and VMs run inside |
| Desktop and browser | Desktop, browser and computer use | Terminal sessions only | 60fps Linux desktop with Chromium and computer use |
| Disk | Files live in memory (about half the RAM); one block volume can be attached at creation | Disk size not published; volumes are experimental, and a volume-backed sandbox cannot be stopped | A real disk that stays, snapshotted every minute and on stop |
| Inbound access and SSH | Preview URL per port, public or token-protected; no raw TCP or public IP; terminal through bl connect, no native SSH | Public HTTPS URL per published port, not behind Docker sign-in; not a TCP tunnel; SSH with Docker-issued certificates | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6; real SSH |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | Allow and deny rules by host, with allow-all, balanced and deny-all presets | Open internet; filter inside the VM with nftables |
| Keeping API keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests; the sandbox never sees them (public preview) | Cloud proxy sets the auth header for built-in AI services and custom hosts; the sandbox sees a placeholder | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code image you drive from its terminal or your own harness | Claude Code, Codex, Copilot, OpenCode and more, run and attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Regions | Oregon, North Virginia, London, Frankfurt | Not published | EU only: Germany, Finland, France, with EU data residency |
| Laptop and cloud | Cloud only | Same microVM and CLI locally or in the cloud; move a sandbox either way | Cloud only |
Every feature Battleships tracks (43)
| Feature | Blaxel | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | 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 | Yes | Yes |
| Automatic snapshots | Yes | Yes | 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 | No | No |
| Wake on request | Yes | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | 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 | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Blaxel and boat ran the same hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB on September 29, 2026: boat did 26.69 runs per second and Blaxel 19.48, about 1.4 times the work in the same time for boat. There is no comparable measurement for Docker Cloud Sandboxes: it launched in September 2026, is not in those runs, and Docker does not say what hardware it uses.
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). Docker Cloud Sandboxes 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 | Blaxel, a month | Docker Cloud 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 | $49 · Docker Agentic Platform (pay-as-you-go) | $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 | $204 · Docker Agentic Platform (pay-as-you-go) · 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,464 · Docker Agentic Platform (pay-as-you-go) · 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 | $700 · Docker Agentic Platform (pay-as-you-go) · 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 | $876 · Pay-as-you-go Tier 2 · with limits | $1,400 · Docker Agentic Platform (pay-as-you-go) · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox has an open connection, with CPU included, and in standby you pay only snapshot storage. Higher tiers unlock when you top up $20 or $50 within 30 days, and the top-up becomes usage credit.
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing, and volumes and egress are free.
Docker Cloud Sandboxes: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Docker ends every sandbox 24 hours after creation and runs 10 at once by default, so it does not fit one agent that never stops, 50 agents in parallel, sandboxes for your users or 1,000 short jobs at once. Blaxel fits the first two, but its self-serve tiers stop at 200 at once, with standby sandboxes counted, so 300 users and 1,000 jobs need a sales tier. On Blaxel's lower tiers sandboxes are deleted after 7 or 30 days. boat has no session cap, but it limits how many machines start per minute, so a 1,000-job burst gets queued.
| Scenario | Blaxel | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite | 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 |
| 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, need provider-side outbound rules, or must run in the US.
- 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.
- Runs longer and wider on its own. Blaxel has no 24-hour session cap, and its self-serve tiers run 50 or 200 sandboxes at once, against Docker's 10.
- Finer outbound rules and known regions. Blaxel can limit traffic down to methods and paths, give static egress IPs, and runs in Oregon, North Virginia, London and Frankfurt.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day.
- The same sandbox on your laptop. If you already run sbx locally, the cloud is the same microVM and CLI, and you can move a sandbox either way.
- SSH and a ready agent lineup. You can SSH in with Docker-issued certificates, and Claude Code, Codex, Copilot and OpenCode are ready to run from the sbx CLI.
- Simple per-second sizes. Pick a size from 1 vCPU / 2 GiB to 16 vCPU / 32 GiB, pay per second with no monthly fee, and pick arm64 where offered.
Where boat fits
If your agents do real work for hours or days, look at boat. Each sandbox is a whole Linux machine with /dev/kvm, systemd, a 60fps desktop and a real disk, with no session cap on paid plans, and you drive the agents inside from outside through one API.
A whole Linux machine, screen included
Without /dev/kvm an Android emulator or VM does not start, and neither Blaxel's Firecracker guests nor Docker's documented sandboxes give it. Docker's sandboxes are also terminal only, so a computer-use agent needs a separate browser service.
A faster CPU and a disk that stays
boat ran 26.69 runs per second against Blaxel's 19.48, so builds and tests wait about 1.4 times longer there. Blaxel keeps files in memory unless you pay for a volume on its full size, and Docker deletes stopped snapshots after 7 days of non-use.
Agents driven from outside, as many as you need
On Blaxel and Docker you reach an agent through its terminal, so you write a wrapper and parse text to know when it is done. Docker also stops each sandbox at 24 hours and runs 10 at once.
Use boat when your agents run for days or by the dozen and need a whole Linux machine: Docker, Android emulators, a desktop, a real disk, a faster CPU and an API to drive them. Compare it one to one: boat vs Blaxel and boat vs Docker Cloud Sandboxes.
Questions people ask
Is Blaxel cheaper than Docker Cloud Sandboxes?
In the scenarios we priced, yes: one coding agent on workdays is $33 a month on Blaxel against $49 on Docker, and 50 agents in parallel is $1,489 on Blaxel against $2,464 on Docker, though Docker does not fit that one. boat is $20 and $317 for the same two.
Which is faster, Blaxel or Docker Cloud Sandboxes?
Only Blaxel has been measured: 19.48 runs per second on a Node.js build-and-test benchmark at 4 vCPU and 8 GB. Docker Cloud Sandboxes is not in that benchmark yet. boat did 26.69 in the same run.
Can a sandbox run longer than 24 hours?
On Blaxel, yes: there is no forced session cap, though Tier 0 and Tier 1 delete sandboxes after 7 or 30 days. On Docker, no: a sandbox ends 24 hours after creation at most. boat has no session cap on paid plans.
Can Blaxel and Docker Cloud Sandboxes run Docker or an Android emulator?
Both run Docker inside: Blaxel through a Docker-in-sandbox image and Docker with its own Docker Engine. An Android emulator needs /dev/kvm, which Blaxel's Firecracker guests do not get and Docker does not document. boat exposes /dev/kvm in every sandbox.
How many sandboxes can I run at once?
Blaxel's self-serve tiers allow 10, 50 or 200, with standby sandboxes counted, and more through sales. Docker allows 10 by default and publishes no way to raise it. boat's $20 plan runs 100 at once, and higher plans go up to 2,000.
Do they keep memory when a sandbox stops?
Both do: Blaxel saves memory and processes in standby and wakes in under 25 ms, and Docker keeps memory and files on stop. boat keeps the disk and boots the machine again on resume, so files stay but running processes do not.
Try boat
Install the CLI, then run boat new.
7-day free trial