Blaxel vs Runloop
Both run each agent in its own VM. Blaxel sleeps seconds after the last connection and wakes in under 25 ms with its memory, while Runloop builds devboxes from Dockerfiles, offers arm64 and can deploy into your own cloud.
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
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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 | Runloop: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month All three fit; Blaxel keeps files in memory unless you attach a volume, Runloop keeps the disk only through suspend or snapshots, and bochka keeps a real disk with /dev/kvm for emulators. | 10th cheapest of 367 $2,373 a month | 20th cheapest of 367 $8,152 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Blaxel's sleep in seconds and wake on request suits mostly idle assistants, Runloop needs the Pro plan to suspend and wake, and bochka runs them on a full VM with a disk that stays. | 12th cheapest of 366 $2,832 a month | 32nd cheapest of 366 $10,194 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 strongest of the three for short code runs, since it sleeps right away and resumes in milliseconds. | 14th cheapest of 345 $144 a month | 44th cheapest of 345 $525 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 Runloop publishes no concurrency cap for paid plans, while Blaxel's public tiers stop at 200 at once; bochka fits 300 at once on a self-serve plan. | 101st of 361, with limits $926 a month | 26th cheapest of 361 $3,301 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 Runloop ranks 4th for RL rollouts: it starts large waves without published start limits and sells RL fine-tuning on Enterprise. | 77th of 360, with limits $4,378 a month | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 ran about 2.3 times Runloop's CPU score, and bochka ran faster than both, so builds and tests finish sooner. | 57th cheapest of 377 $431 a month | 121st cheapest of 377 $1,554 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Runloop has SSH through a TLS proxy and Blaxel has no native SSH; bochka is a plain machine you SSH into and leave on. | 265th of 368, with limits $114 a month | 113th cheapest of 368 $410 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 | 14th cheapest of 369 $634 a month | 39th cheapest of 369 $2,306 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 | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 Both fit; Blaxel adds method and path egress rules and static egress IPs, Runloop a hostname allowlist, and bochka gives root with raw TCP. | 3rd cheapest of 360 $217 a month | 10th cheapest of 360 $770 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 | Runloop | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM, own kernel | Micro-VM on a custom hypervisor, plus a container layer | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU speed (Node.js benchmark, 4 vCPU / 8 GB) | 19.48 runs a second | 8.29 runs a second | 26.69 runs a second |
| Sleep and wake | Standby seconds after the last connection, wakes in under 25 ms with memory and processes | Suspend after idle, wake on an HTTP request to the tunnel (Pro plan) | Stop keeps the disk and costs nothing; resume boots the VM again |
| Keeping files | Files live in memory (about half the RAM); one block volume can be attached at creation | Disk kept through suspend (Pro) or manual snapshots; shutdown ends the devbox | Real disk snapshotted every minute and on stop, on every plan |
| Long runs | No forced session cap; Tier 0 and 1 delete sandboxes after 7 or 30 days | Lifetime 1 hour by default, 48 hours max; an idle policy replaces it | No session cap on paid plans; default TTL 1 hour, changeable |
| Fork | Fork with memory and running processes (private preview) | Fork a running devbox (disk, no memory) | Fork a running sandbox (disk) |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | Not documented; Docker-in-Docker blueprints only | Yes: /dev/kvm, so Android emulators and VMs run inside |
| Docker inside | Yes, with a Docker-in-sandbox image | Yes, on the dnd blueprints, as root | Yes, with root and systemd |
| Images and architecture | Custom images from Docker images, x86_64 | Blueprints from Dockerfiles, x86_64 and arm64 | Templates from named snapshots, x86_64 only |
| SSH | No native SSH; terminal through bl connect | SSH through a TLS proxy | Real SSH, root and systemd |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP or public IP | One HTTPS tunnel per devbox, open or bearer token; no public IP | HTTPS URLs for up to 50 ports, token-protected by default, raw TCP, own IPv6 or IPv4 |
| Outbound rules | Domain lists, method and path rules, static egress IPs | Hostname allowlist with wildcards, or block all | Open internet; filter inside the VM with nftables |
| Hidden API keys | Proxy fills secrets into outbound HTTPS requests (public preview) | Agent gateways for any API endpoint | Credentials proxy for model providers and any HTTPS API; switch to another account when one runs out |
| Where it runs | Oregon, North Virginia, London, Frankfurt | Regions not documented; deploy to your own AWS, GCP or Azure (Enterprise) | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Blaxel | Runloop | bochka |
|---|---|---|---|
| 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 | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | 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 | No | 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 | Yes | 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 | Yes | 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 | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Yes | 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 | Yes | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | 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. bochka did 26.69 runs a second, Blaxel 19.48 and Runloop 8.29, so Blaxel did about 2.3 times Runloop's work and bochka about 1.4 times Blaxel's. The test measures CPU work only, not start time or network speed.
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).
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 | Runloop, 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 | $113 · Basic | $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 | $429 · Basic | $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 | $5,268 · Basic | $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 | $1,441 · Basic | $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,184 · Basic | $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 the tier you reach depends on how much you top up each month.
Runloop: Runloop bills per second for allocated CPU and memory while a devbox starts, runs, suspends or resumes, and bills its disk for its whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit.
Runloop: Plans start at $20 a month and the whole fee is usage credit, billed per second while a sandbox 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, counting those in standby, so the 300-user and 1,000-job scenarios need a sales tier. Runloop fits both scenarios, since it publishes no concurrency cap for paid plans, but it publishes no egress price and its fixed lifetime tops out at 48 hours unless you set an idle policy. bochka fits 300 users at once but queues bursts above 90 starts a minute, so 1,000 jobs at once does not fit.
| Scenario | Blaxel | Runloop | 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 must run in the US with fine-grained egress rules.
- Sleeps in seconds, wakes in milliseconds. For sandboxes that sit idle most of the time: Blaxel sleeps after the last connection and wakes in under 25 ms with memory intact.
- About 2.3 times Runloop's CPU score. On the same Node.js benchmark Blaxel ran 19.48 runs a second and Runloop 8.29, so builds and tests finish sooner.
- Finer network rules and US regions. Blaxel can limit traffic by domain, method and path with static egress IPs, and runs in Oregon and North Virginia.
Use Runloop when
you launch very large waves of sandboxes, need arm64 or Dockerfile blueprints, or want devboxes inside your own AWS, GCP or Azure account.
- No published concurrency cap. For big waves of sandboxes: Runloop publishes no concurrency cap on paid plans, while Blaxel's public tiers stop at 200.
- Dockerfiles and arm64. Runloop builds blueprints from Dockerfiles and offers arm64 machines, which helps teams that build for ARM.
- Run it in your own cloud. On the Enterprise plan, Runloop can run devboxes inside your own AWS, GCP or Azure account.
Where bochka fits
Blaxel and Runloop are both built around short-lived or sleeping sandboxes. If your agents do real work for hours, with installs, builds, Docker and emulators, bochka gives each one a whole Linux machine with a disk that stays and the fastest CPU of the three.
A whole Linux machine
Neither Blaxel nor Runloop documents /dev/kvm, so an Android emulator or a VM does not start. Blaxel has no native SSH and neither gives raw TCP, so tools and servers that expect them need workarounds.
A disk that stays, on every plan
Blaxel keeps files in about half the RAM unless you attach a volume at creation. Runloop deletes the disk at shutdown, so keeping work means the $250-a-month Pro plan or snapshot code you maintain.
A faster CPU and agents driven from outside
bochka ran 26.69 runs a second, against 19.48 on Blaxel and 8.29 on Runloop, so agents wait less on builds. Claude Code, Codex and others come installed, and you drive agents inside from outside with one API.
Use bochka when your agents do real work for hours: builds, tests, Docker and emulators on a whole Linux machine with a disk that stays and the fastest CPU of the three. Compare it one to one: bochka vs Blaxel and bochka vs Runloop.
Questions people ask
Is Blaxel cheaper than Runloop?
In every scenario we priced, yes. One coding agent on workdays costs $33 a month on Blaxel and $113 on Runloop, and 50 agents in parallel $1,489 against $5,268. bochka costs $20 and $317 for the same two.
Which is faster, Blaxel or Runloop?
On the same Node.js build-and-test benchmark at 4 vCPU and 8 GB, Blaxel ran 19.48 runs a second and Runloop 8.29. bochka ran 26.69 in the same run.
Can Blaxel and Runloop run Docker?
Yes. Blaxel has a Docker-in-sandbox image and Runloop has Docker-in-Docker blueprints. Neither documents /dev/kvm for Android emulators or VMs, which bochka exposes in every sandbox.
Which one keeps my files between runs?
Blaxel keeps files in memory through standby, and lower tiers delete sandboxes after 7 or 30 days; a volume gives you a real disk. Runloop keeps the disk only through suspend on Pro or in snapshots. bochka snapshots the disk every minute and on stop, on every plan.
How many sandboxes can run at once?
Blaxel's self-serve tiers allow 10, 50 or 200 at once, standby included. Runloop publishes a cap of 3 only for its trial and none for paid plans.
Where do Blaxel and Runloop run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. Runloop does not document its regions but can deploy into your own AWS, GCP or Azure account on Enterprise. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview