Blaxel vs Agent 37
Blaxel gives every sandbox its own kernel in a Firecracker microVM that sleeps in seconds and wakes in under 25 ms. Agent 37 starts with lighter gVisor sandboxes, one per user, that cost much less per hour, and sells a full VM type when you need Docker or KVM.
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
Agent 37
Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.
You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.
- Where it runs
- Dedicated servers in the United States
- Instance types
- Default (shared), Performance (dedicated cores), VM
- Compliance
- SOC 2 Type I, Type II in progress
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 | Agent 37: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month boat gives Docker, systemd and /dev/kvm in every sandbox; Blaxel runs Docker but has no /dev/kvm and keeps files in memory, and Agent 37 needs its VM type at 2.5 times the compute rate. | 10th cheapest of 367 $2,373 a month | 2nd cheapest of 367 $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both suit mostly idle assistants that sleep and keep their memory: Agent 37 is built for one per user, Blaxel wakes faster, and boat keeps them on a full VM with a disk that stays. | 12th cheapest of 366 $2,832 a month | Cheapest of 366 $279 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's millisecond wake and Agent 37's small default sandboxes both suit short code runs, while boat's start limits make large bursts a poor fit. | 14th cheapest of 345 $144 a month | Cheapest of 345 $22 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 and Agent 37 both stop at 200 sandboxes at once on self-serve tiers, counting sleeping ones, while boat fits 300 users at once on a self-serve plan. | 101st of 361, with limits $926 a month | 30th of 361, with limits $79 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 | 6th of 360, with limits $363 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 boat starts a fresh VM per task from a named snapshot, while the self-serve tiers of both Blaxel and Agent 37 cap how many run at once at 200. | 136th of 364, with limits $704 a month | 90th of 364, with limits $58 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 | 57th cheapest of 377 $431 a month | 2nd cheapest of 377 $84 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Agent 37 keeps a disk around the clock at a low idle cost with SSH through a tunnel, Blaxel has no native SSH, and boat is a plain machine with SSH and systemd. | 265th of 368, with limits $114 a month | 3rd cheapest of 368 $12 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 and boat both run a desktop and a browser, boat streams a 60fps desktop you can embed, and Agent 37 adds a noVNC desktop through a template build. | 14th cheapest of 369 $634 a month | Cheapest of 369 $53 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 | 48th of 367, with limits $29 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 | Cheapest of 346 $32 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 | 36th of 338, with limits $648 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 All three fit: Blaxel adds domain-level egress rules, boat can fork an attempt that is already running, and Agent 37 has no fork. | 3rd cheapest of 360 $217 a month | Cheapest of 360 $43 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 | Agent 37 | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | gVisor by default; full VM with its own kernel as an opt-in type | Full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Yes, with a Docker-in-sandbox image | Only on the VM type, at 2.5x the default compute rate | Yes, in every sandbox |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | /dev/kvm on the VM type, with a ready Android template | /dev/kvm in every sandbox, so Android emulators and VMs run inside |
| SSH and systemd | Root, terminal through bl connect, no native SSH | Root SSH through a WebSocket tunnel; your entrypoint is PID 1 with no init system | Real SSH, root and systemd |
| Disk | Files live in memory (about half the RAM); one block volume can be attached at creation | Disk that stays, capped by shape (at most 20 GB on 4 vCPU / 8 GB) | A real disk that stays, snapshotted every minute and on stop |
| Sleep and wake | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | Opt-in auto-sleep after a quiet period (default 15 minutes), memory checkpointed, wakes in a few seconds | No idle timer; stop keeps the disk and costs nothing, resume reboots the VM |
| Fork | Fork with memory and running processes (private preview) | No fork; daily backups plus one on-demand backup, restored in place only | Fork a running sandbox (disk); named snapshots as shareable templates |
| Custom images | Custom images built from Docker images | Your own linux/amd64 Docker image as a template | Templates from named snapshots, no Dockerfile builds |
| CPU | CPU bundled with RAM (8 GB comes with 4 cores); 19.48 runs/s measured | Shared by default; Performance type on dedicated cores at 4x the compute rate; no published score | Shared vCPUs on dedicated AMD Ryzen 9 9950X hosts; 26.69 runs/s measured |
| Built-in agents | Claude Code image you drive from its terminal or your own harness | Hermes, OpenClaw, Claude Code, Codex, Grok, OpenCode, Pi, with a chat API per instance | Claude Code, Codex, OpenCode, pi and more, with a prompt, steer and events API |
| Keys kept out of the sandbox | Proxy fills secrets into outbound HTTPS requests (public preview) | Managed LLM, search and Composio through a per-instance token; your own keys go in as env vars | Proxy for model providers and any HTTPS API you register; switch a credential to another account when one runs out of credits |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP or public IP | HTTPS URL per port, signed URLs, custom domains; no public IP | 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, no provider-side allow list | Open internet; filter inside the VM with nftables |
| Regions | US (Oregon, North Virginia), London, Frankfurt | United States | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Blaxel | Agent 37 | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | 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 | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | 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 | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | 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, run on September 29, 2026, boat did 26.69 runs per second and Blaxel 19.48. Higher is better. Agent 37 has no result on that benchmark, so there is no comparable measurement; it says its default instances share host resources and sells a Performance type on dedicated cores.
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). Agent 37 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 | Agent 37, 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 | $6 · Wallet (any top-up) | $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 | $12 · Wallet (any top-up) | $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 | $329 · Wallet ($100 lifetime top-ups) | $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 | $33 · Wallet ($250 lifetime top-ups) · 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 | $73 · Wallet ($250 lifetime top-ups) · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox is active, meaning a connection is open, with CPU included. In standby you pay only snapshot storage, and volumes are billed on their full size.
Agent 37: Agent 37 uses a prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM per month while running, and $0.09 per GB of disk per month even while asleep. Performance compute costs 4x and VM compute 2.5x.
Agent 37: A monthly plan from $20, all of it 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 Agent 37's allow 1, 10, 50 or 200; both count sleeping sandboxes, so neither fits 300 users or 1,000 jobs at once without talking to them. Blaxel's lower tiers delete sandboxes after 7 or 30 days, and Agent 37 caps disk per shape (20 GB on 4 vCPU / 8 GB). The 50-agent scenario needs Docker, so it is priced on Agent 37's VM type. boat's plans allow up to 2,000 at once, but it caps how many machines start per minute, so 1,000 jobs at the same moment get queued.
| Scenario | Blaxel | Agent 37 | 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 |
| 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 network rules, or must run in Europe and the US.
- Wakes in milliseconds. For sandboxes that sit idle most of the time: Blaxel sleeps seconds after the last connection and wakes in under 25 ms.
- Own kernel and Docker by default. Every Blaxel sandbox is a microVM with its own kernel and can run Docker, with no pricier instance type to switch to.
- Network rules and more regions. Blaxel can lock a sandbox to chosen domains and paths, and runs in London and Frankfurt as well as the US.
Use Agent 37 when
you host one mostly idle assistant per customer in the US and want the lowest hourly rate, with ready agent templates and a chat API.
- Much lower hourly rates. For agents that run all month: our always-on scenario comes to $12 on Agent 37 against $120 on Blaxel.
- Ready agents with a chat API. Agent 37 starts an instance from Hermes, OpenClaw, Claude Code, Codex and other templates, and gives each one a chat API.
- A VM type with KVM when you need it. Agent 37's VM type adds Docker and /dev/kvm, with a ready Android template, which Blaxel's microVMs cannot offer.
Where boat fits
Blaxel and Agent 37 are both built around sandboxes that sleep when idle. If your agents do hours of real work instead, like installs, builds, tests, Docker and emulators, boat gives each one a whole Linux machine with a real disk and a faster CPU. It also forks running machines and keeps your keys outside for any API, in the EU.
A whole Linux machine in every sandbox
Blaxel has no /dev/kvm and no native SSH, so an Android emulator never starts. On Agent 37, Docker and KVM need the VM type at 2.5 times the compute rate, and it still has no init system.
Fork a machine while it runs
Agent 37 has no fork, and backups only restore onto the same instance, so each try rebuilds its state from the start. Blaxel's fork is in private preview, and its files sit in memory unless you attach a volume at creation.
A faster CPU
boat ran 26.69 runs per second against Blaxel's 19.48, so every build and test waits about 1.4 times as long on Blaxel. Agent 37 publishes no score, and steady speed there means its Performance type at 4 times the rate.
Use boat when your agents do real work for hours: builds, tests, Docker and emulators on a full VM with a real disk, a faster CPU, forks of running machines and keys kept outside for any API. Compare it one to one: boat vs Blaxel and boat vs Agent 37.
Questions people ask
Is Blaxel cheaper than Agent 37?
No. Agent 37 is lower in every scenario we priced: $6 against $33 for one coding agent on workdays, $12 against $120 for one that never stops, and $329 against $1,489 for 50 agents in parallel. Blaxel bills only while a connection is open, so a workload that disconnects often pays less than these numbers.
Which is faster, Blaxel or Agent 37?
Blaxel ran 19.48 runs per second on the Node.js build-and-test benchmark at 4 vCPU and 8 GB. Agent 37 has no result on it, so they cannot be compared directly. boat ran 26.69 on the same benchmark.
Can Blaxel or Agent 37 run Docker?
Blaxel can, with its Docker-in-sandbox image. Agent 37 can only on its VM type, which bills compute at 2.5x; the default gVisor type cannot run a Docker daemon. On boat, Docker works in every sandbox.
Do Blaxel and Agent 37 keep memory when a sandbox sleeps?
Both do. Blaxel goes to standby seconds after the last connection and wakes in under 25 ms. Agent 37 sleeps after a quiet period you choose and wakes in a few seconds. boat keeps the disk on stop and reboots on resume.
Can I SSH into Blaxel or Agent 37?
Agent 37 has root SSH through a WebSocket tunnel. Blaxel has no native SSH; you get a terminal through the bl connect command. boat gives real SSH and systemd in every sandbox.
Where do Blaxel and Agent 37 run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. Agent 37 runs on dedicated servers in the United States. boat runs only in the EU, in Germany, Finland and France.
Try boat
Install the CLI, then run boat new.
7-day free trial