Blaxel vs Deno Sandbox
Both run each sandbox in a Firecracker microVM. Blaxel keeps a sandbox around, asleep with its memory saved, and wakes it in under 25 ms, while Deno Sandbox starts a fresh 2 vCPU machine in under 200 ms that lives up to 30 minutes.
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
Deno Sandbox
Deno Sandbox is part of Deno Deploy, the hosting platform from the company behind the Deno runtime, and runs untrusted or AI-generated code in Linux microVMs.
Each sandbox is a Firecracker microVM with 2 vCPU, up to 4 GB of memory and a 10 GB disk that is wiped when it ends, created from a TypeScript or Python SDK. Outbound traffic goes through a proxy that can enforce a host allowlist and swap placeholder secrets for real ones. It is built for short runs of agent or user code, and a sandbox can be promoted to a Deno Deploy app.
- Isolation
- Firecracker microVM per sandbox
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 | Deno Sandbox: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Blaxel fits a software factory with 4 vCPU / 8 GB machines that keep running, while Deno's 30-minute lifetime and 2 vCPU shape cut builds short; bochka adds /dev/kvm and a real disk. | 10th cheapest of 367 $2,373 a month | 290th of 367, with limits $5,665 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Blaxel's sleep and wake on request suits mostly idle assistants, while a Deno sandbox ends after 30 minutes and wipes its disk. | 12th cheapest of 366 $2,832 a month | 287th of 366, with limits $5,803 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 suit short code runs: Blaxel wakes in under 25 ms with memory intact, and Deno starts in under 200 ms and bills CPU only while code runs. | 14th cheapest of 345 $144 a month | 141st of 345, with limits $329 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 Blaxel's public tiers stop at 200 at once and Deno Builder at 20 per region, while bochka fits 300 users at once on a self-serve plan. | 101st of 361, with limits $926 a month | 148th of 361, with limits $1,863 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 | 122nd of 360, with limits $7,963 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 Blaxel's public tiers cap runs at 200 at once and Deno Builder at 20 per region, while bochka starts a fresh VM per task from a named snapshot. | 136th of 364, with limits $704 a month | 296th of 364, with limits $1,563 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 run Docker fit Blaxel with its Docker-in-sandbox image, while Deno does not document Docker; bochka also exposes /dev/kvm for Android emulators. | 57th cheapest of 377 $431 a month | 304th of 377, with limits $731 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 leave on: Blaxel has no native SSH and Deno ends a sandbox after 30 minutes, while bochka is a VM you SSH into and keep. | 265th of 368, with limits $114 a month | 179th of 368, with limits $200 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 for computer use and Deno Sandbox has none; bochka streams a 60fps desktop with Chromium. | 14th cheapest of 369 $634 a month | 280th of 369, with limits $1,583 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 | 284th of 367, with limits $783 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 | 286th of 346, with limits $573 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 | 247th of 338, with limits $11,923 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 | 251st of 360, with limits $367 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 | Deno Sandbox | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Sized by RAM with CPU included (8 GB comes with 4 cores); larger sizes on Custom | 2 vCPU fixed, 768 MB to 4 GB memory, 10 GB disk | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No cap on an active session; Tier 0 and 1 delete sandboxes after 7 or 30 days | Up to 30 minutes; longer work can be promoted to a Deno Deploy app | No cap on paid plans; you set the time to live |
| Sleep and wake | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | No pause or resume; a new sandbox starts in under 200 ms | Stop keeps the disk and costs nothing; resume boots the VM again |
| Disk | Files live in memory (about half the RAM); one block volume can be attached at creation | Root disk wiped when the sandbox ends; volumes of 300 MB to 20 GB, Chicago only | A real disk that stays, saved every minute and on stop |
| Fork | Fork with memory and running processes (private preview) | No fork; read-only volume snapshots that many new sandboxes can boot from | Fork a running sandbox with its disk |
| Docker and nested virtualization | Docker with a Docker-in-sandbox image; no /dev/kvm | Root access; Docker and nested virtualization not documented | Docker, systemd and /dev/kvm for Android emulators and VMs |
| SSH | Root, terminal through the bl connect command, no native SSH | SSH and a VS Code editor in the browser | Real SSH, root and systemd |
| Desktop and browser | Desktop and browser for computer use | No desktop or browser | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Inbound access | Preview URL per port, public or token-protected; no raw TCP or public IP | HTTPS URL per exposed port, public without authentication | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | Host allowlist per sandbox, enforced by a proxy outside the VM | Open internet; filter inside the VM with nftables |
| Keeping API keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests (public preview) | Placeholder secrets swapped for real ones on requests to approved hosts | 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 | A root image with Claude Code, run through the shell command API | Seven agents preinstalled, with a prompt, steer and events API |
| Regions | Oregon, North Virginia, London, Frankfurt | Amsterdam and Chicago | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Blaxel | Deno Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | 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 | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | 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 | 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 | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
Blaxel and bochka ran the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB in the same run on September 29, 2026: bochka did 26.69 runs per second and Blaxel 19.48, about 1.4 times the work for bochka. Deno Sandbox has no comparable measurement, since it is not in that benchmark and its fixed 2 vCPU shape could not run the 4 vCPU test.
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). Deno Sandbox 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 | Deno Sandbox, 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 | $33 · Pay-as-you-go Tier 1 | $53 · Pro · 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 | $200 · Builder · 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,779 · Builder · 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 | $783 · Builder · 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,563 · Builder · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox is active, with CPU included. In standby you pay only snapshot storage, and volumes are billed on their full size.
Deno Sandbox: Sandboxes need the Pro plan at $20 a month or Builder at $200 a month, which include allowances shared with Deno Deploy apps. Past those, CPU costs $0.10 per hour of active CPU time and memory $0.025 per GiB-hour for the whole life of the sandbox.
Deno Sandbox: 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
Deno Sandbox fits none of the five scenarios as written: a sandbox lives up to 30 minutes, is fixed at 2 vCPU with up to 4 GB, and Builder allows 20 at once per region. Blaxel fits the workday agent, the always-on agent and 50 agents in parallel, but its Tier 2 stops at 200 at once, and standby sandboxes count, so 300 users and 1,000 jobs need a sales tier. bochka fits four of the five; for 1,000 jobs at once it queues starts above 90 a minute, so none of the three fits that one without a custom plan.
| Scenario | Blaxel | Deno Sandbox | 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 |
| 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 fine outbound rules and static egress IPs.
- Sleeps and wakes with its memory. Useful for sandboxes that sit idle: one sleeps seconds after the last connection and wakes in under 25 ms where it was.
- Bigger machines that keep running. For agents that work for hours: a 4 vCPU / 8 GB sandbox has no 30-minute limit and can run Docker.
- Fine network rules. For teams that must control traffic: limit domains down to methods and paths, and give a sandbox static egress IPs.
Use Deno Sandbox when
you run short pieces of untrusted code that must start fast, reach only the hosts you allow, and live on Deno Deploy.
- CPU billed only while code runs. Good for short bursts: a sandbox starts in under 200 ms and CPU bills only while code is running.
- A path to Deno Deploy. Fits teams already on Deno Deploy: a sandbox can be promoted to a Deploy app on the same meters.
- SSH and an editor in the browser. Handy for looking inside a run: each sandbox offers SSH and a VS Code editor in the browser.
Where bochka fits
Both Blaxel and Deno Sandbox are microVMs tuned for quick starts. If your agents do real work for hours, with builds, Docker, emulators and a browser, bochka gives each one a whole Linux machine with a disk that stays and coding agents you drive from outside through one API.
A whole Linux machine
bochka has systemd, real SSH, Docker and /dev/kvm. Blaxel's Firecracker guests get no /dev/kvm and no native SSH, and Deno does not document Docker at all, so an Android emulator or a VM will not start on either.
A disk that is still there tomorrow
Blaxel keeps files in memory, about half the RAM, unless you attach a volume at creation. Deno wipes the root disk when a sandbox ends after at most 30 minutes, and its volumes exist only in Chicago.
A faster CPU and a bigger machine
On the same build-and-test benchmark bochka ran 26.69 runs per second and Blaxel 19.48, so every install and test waits about 1.4 times as long on Blaxel. Deno is fixed at 2 vCPU and 4 GB.
Use bochka when your agents do real work for hours: builds, tests, Docker, emulators and a browser on a whole Linux machine with a faster CPU and a disk that stays. Compare it one to one: bochka vs Blaxel and bochka vs Deno Sandbox.
Questions people ask
Is Blaxel cheaper than Deno Sandbox?
In all five scenarios we priced, Blaxel comes out lower: one agent that never stops is $120 against $200 a month, and 50 agents in parallel $1,489 against $2,779. Deno Sandbox does not fit any of them as written. bochka is lower than both in four of the five, for example $317 for the 50 agents.
Which is faster, Blaxel or Deno Sandbox?
Only Blaxel has a CPU measurement: 19.48 runs per second at 4 vCPU / 8 GB, against 26.69 for bochka. Deno Sandbox is not in the benchmark. For start time, Blaxel wakes from standby in under 25 ms and Deno starts a new sandbox in under 200 ms.
Can Blaxel or Deno Sandbox run Docker?
Blaxel can, with its Docker-in-sandbox image, but it has no /dev/kvm for emulators. Deno's docs do not say Docker works inside a sandbox. bochka runs Docker and systemd and exposes /dev/kvm.
How long can a sandbox run on Blaxel and Deno Sandbox?
A Deno sandbox lives up to 30 minutes, and longer work can be promoted to a Deno Deploy app. Blaxel has no cap on an active session, though Tier 0 and 1 delete sandboxes after 7 or 30 days. bochka has no cap on paid plans.
Do Blaxel and Deno Sandbox keep files?
Blaxel keeps files in memory through standby, and a volume attached at creation holds more. Deno wipes the root disk when a sandbox ends unless you mount a volume, which exists only in Chicago. bochka keeps the whole disk and saves it every minute.
Try bochka
Install the CLI, then run bochka new.
Product preview