Blaxel vs exe.dev
Blaxel gives each sandbox a Firecracker microVM that sleeps seconds after the last connection and wakes in under 25 ms with its memory. exe.dev rents full Linux VMs with SSH and systemd that share a reserved pool and keep running until you stop them.
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
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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 | exe.dev: 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 fully, while exe.dev is a compromise here; bochka adds /dev/kvm for emulators and a snapshot every minute. | 10th cheapest of 367 $2,373 a month | 253rd of 367, with limits $3,701 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both fit always-on assistants: Blaxel sleeps them between requests, exe.dev keeps each one on a VM with a lasting disk. | 12th cheapest of 366 $2,832 a month | 15th cheapest of 366 $3,833 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 fits short code runs well, since a sandbox sleeps right away and wakes in milliseconds, while exe.dev pools bill whether the VMs are busy or not. | 14th cheapest of 345 $144 a month | 235th of 345, with limits $175 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 For sandboxes you hand to your users, Blaxel's public tiers stop at 200 at once and exe.dev Personal at 50, while bochka fits 300 at once on a self-serve plan. | 101st of 361, with limits $926 a month | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 Blaxel's per-second billing on active time suits CI better than exe.dev pools, which bill whether jobs run or not. | 57th cheapest of 377 $431 a month | 288th of 377, with limits $504 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev fits a 24/7 dev box you SSH into and leave on, while Blaxel has no native SSH and bills every active second; bochka also fits, with a desktop in the browser. | 265th of 368, with limits $114 a month | 25th cheapest of 368 $35 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 can run a desktop and a browser for computer-use agents, while exe.dev VMs are headless; bochka streams a 60fps desktop you can embed. | 14th cheapest of 369 $634 a month | 240th of 369, with limits $1,055 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 | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 Blaxel fits parallel red teaming fully with domain-level egress rules, while exe.dev is a compromise; bochka gives root with raw TCP and nftables. | 3rd cheapest of 360 $217 a month | 60th of 360, with limits $263 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 | exe.dev | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM, own kernel | KVM VM with Cloud Hypervisor; you can't choose the kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| SSH and systemd | Root, terminal through bl connect, no native SSH | Root, systemd and SSH | Real SSH, root and systemd |
| Sleep and wake | Standby seconds after the last connection, wakes in under 25 ms with memory and processes | VMs run until you stop them; no idle sleep | Stop keeps the disk and costs nothing; resume boots the VM again |
| Disk and saved state | Files live in memory (about half the RAM); one volume can be attached at creation | Disk persists and is streamed to a second server; no snapshots | A real disk that stays, snapshotted every minute and on stop |
| Fork | Fork with memory and running processes (private preview) | cp copies a VM's disk and config into a new VM | Fork a running sandbox (disk); named snapshots as templates |
| Custom images | Custom images built from Docker images | Boot from your own Docker image | Templates from named snapshots; no Dockerfile or OCI images |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | Enterprise only | Yes, /dev/kvm on every plan |
| Desktop and computer use | Desktop, browser and computer use | Headless; no desktop or screen streaming | 60fps desktop and Chromium, computer use, browser control, embeddable stream |
| Agent API | Claude Code image you drive from its terminal or your own harness | Prompt Shelley through the CLI or HTTPS API; other agents through shell commands | Prompt, steer and stream events for Claude Code, Codex, pi, OpenCode and more |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP or public IP | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; own IPv6 or IPv4 |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | Open internet; filter inside the VM | Open internet; filter inside the VM with nftables |
| Secrets | Proxy fills secrets into outbound HTTPS requests (public preview) | Integrations inject secrets at the network edge for any HTTP host | Credentials proxy for model providers and any HTTPS API you register |
| Regions | Oregon, North Virginia, London, Frankfurt | 9 regions in the US, Europe, Asia and Australia | EU only: Germany, Finland, France |
| Billing | Allocated RAM per active second, CPU included | Reserved pool billed flat, or standalone VMs per second | Plan fee is all usage credit, billed per second while running |
Every feature Battleships tracks (43)
| Feature | Blaxel | exe.dev | bochka |
|---|---|---|---|
| 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 | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | No | 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 | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Yes | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | 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 | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB, Blaxel did 19.48 runs per second and bochka 26.69, so bochka does about 1.4 times the work in the same time. exe.dev is not in that run, so there is no comparable CPU measurement for it, and we don't guess its score.
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). exe.dev 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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 | $1,848 · Personal | $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 | $530 · Personal · 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,050 · Personal · 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. In standby you pay only snapshot storage, and volumes are billed on their full size.
exe.dev: exe.dev Personal is a reserved pool billed flat each month whether its VMs are busy or idle, from $15 for 2 vCPU / 4 GiB. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
exe.dev: 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
Blaxel's self-serve tiers allow 10, 50 or 200 sandboxes at once, and sandboxes in standby count toward that, so 300 users or 1,000 jobs at once need a sales tier. exe.dev Personal stops at 50 VMs at once, so those two scenarios don't fit there either. Blaxel's lower tiers also delete sandboxes after 7 or 30 days. bochka allows 100 to 2,000 at once by plan, but limits how fast machines start, so 1,000 jobs at the same moment get queued.
| Scenario | Blaxel | exe.dev | 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 | 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 domain-level outbound rules.
- Sleeps in seconds, wakes in milliseconds. Useful if your sandboxes sit idle most of the time: they sleep after the last connection and wake in under 25 ms.
- Network rules on the provider side. Blaxel can limit a sandbox to chosen domains, down to methods and paths, and give it static egress IPs.
- Fork with memory. Blaxel can fork a sandbox with its memory and running processes, in private preview, so copies start mid-task.
Use exe.dev when
you want a plain VM you SSH into and leave on, in a region outside Europe, with SSO and roles for your team.
- A plain dev box over SSH. exe.dev gives you a full VM with root, systemd and real SSH that runs until you stop it.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- Team controls and an MCP server. Its Work plan covers a whole team with SSO and roles, and it serves an MCP server for controlling VMs.
Where bochka fits
Blaxel is built for sandboxes that sleep most of the time, and exe.dev for VMs you keep in a pool and reach over SSH. If your agents do hours of real work, with builds, Docker, emulators and a screen, bochka gives each one a whole Linux machine with a faster CPU, a disk saved every minute and one API to drive agents inside from outside.
Nested virtualization on every plan
Without /dev/kvm an Android emulator or a VM inside the sandbox does not start. Blaxel's Firecracker guests never get it, and exe.dev offers it only on Enterprise.
A disk saved every minute
Agents sometimes wreck an install or delete files. exe.dev has no snapshots to roll back to, and Blaxel keeps files in memory unless you attach a volume at creation, so one bad step can cost a session's work.
A screen and agents you can drive
exe.dev VMs are headless and only Shelley takes prompts through its API, and Blaxel's Claude Code image is driven from a terminal or your own harness. bochka streams a 60fps desktop and lets you prompt and steer any built-in agent.
Use bochka when your agents do real work for hours: builds, tests, Docker and emulators on a whole Linux machine with a faster CPU, a desktop, a disk saved every minute and one API to drive agents inside from outside. Compare it one to one: bochka vs Blaxel and bochka vs exe.dev.
Questions people ask
Is Blaxel cheaper than exe.dev?
In most of our scenarios, yes: one coding agent on workdays is $33 on Blaxel against $35 on exe.dev, and 50 agents in parallel $1,489 against $1,848. For one agent that never stops, exe.dev's flat pool wins at $35 against $120. bochka is $20, $317 and $26 for those three.
Which is faster, Blaxel or exe.dev?
We can't say, because exe.dev has no score in the benchmark run we use. Blaxel did 19.48 runs per second on the Node.js build-and-test loop at 4 vCPU and 8 GB, and bochka did 26.69.
Can Blaxel and exe.dev run Docker?
Yes. Blaxel runs Docker with its Docker-in-sandbox image, and exe.dev VMs come with Docker and can boot from your own Docker image. bochka runs Docker in every sandbox too.
Do Blaxel and exe.dev have SSH?
exe.dev does: every VM has real SSH, root and systemd. Blaxel has no native SSH; you get a terminal through the bl connect command. bochka gives real SSH, root and systemd.
Can I run an Android emulator on Blaxel or exe.dev?
An emulator needs /dev/kvm. Blaxel's Firecracker guests do not get it, and exe.dev offers nested virtualization only on Enterprise. bochka exposes /dev/kvm on every plan.
Where do Blaxel and exe.dev run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. exe.dev has nine regions in the US, Europe, Asia and Australia. 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