Blaxel vs Google Agent Runtime
Blaxel gives every sandbox its own microVM with root and Docker, and puts it to sleep seconds after the last connection. Google Agent Runtime hosts your agent code inside Google Cloud and runs its tools in locked containers as a user with no sudo.
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
Google Agent Runtime
Google Agent Runtime is the agent hosting part of Gemini Enterprise Agent Platform on Google Cloud, renamed from Vertex AI Agent Engine in April 2026.
It is a hyperscaler service, not a sandbox company. Agent Runtime deploys agents you build with ADK, LangGraph, LangChain, AG2 or LlamaIndex and bills them only while they work on a turn. Next to it, Agent Sandbox gives those agents a place to run code: a Code Execution sandbox, a shell or custom container sandbox, and a Computer Use browser. All of them run as secure containers inside your Google Cloud project.
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 | Google Agent Runtime: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Blaxel fits a software factory because it has root and Docker, while Google's sandboxes have neither; boat adds /dev/kvm for emulators and a real disk. | 10th cheapest of 367 $2,373 a month | 295th of 367, with limits $5,801 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 12th cheapest of 366 $2,832 a month | 28th cheapest of 366 $7,519 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 ranks 14th here, since short runs that sleep at once and wake in milliseconds are what it is built for; Google's Code Execution sandbox is a ready Python interpreter with no network. | 14th cheapest of 345 $144 a month | 254th of 345, with limits $275 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 sandboxes at once and Google gives users no public URL, while boat ranks 1st with 300 at once and HTTPS on up to 50 ports. | 101st of 361, with limits $926 a month | 280th of 361, with limits $1,916 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 | 128th of 360, with limits $8,240 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 Google fits this one fully while Blaxel's public tiers cap how many run at once at 200; boat starts a fresh VM per task from a named snapshot. | 136th of 364, with limits $704 a month | 79th cheapest of 364 $2,060 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 runs Docker with its Docker-in-sandbox image, which CI jobs that build containers need, and Google's unprivileged sandboxes do not. | 57th cheapest of 377 $431 a month | 98th cheapest of 377 $989 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither has native SSH, so neither works well as a box you log into and leave on; boat gives you SSH and a disk that stays. | 265th of 368, with limits $114 a month | 311th of 368, with limits $241 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 Google gives you only a browser with a VNC view; boat streams a 60fps desktop you can embed. | 14th cheapest of 369 $634 a month | 283rd of 369, with limits $1,648 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 | 102nd of 367, with limits $824 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 | 53rd cheapest of 346 $515 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 | 210th of 338, with limits $8,240 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 ranks 3rd with root and domain-level egress rules, while Google's sandboxes run without root; boat ranks 2nd with root, raw TCP and nftables. | 3rd cheapest of 360 $217 a month | 260th of 360, with limits $412 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 | Google Agent Runtime | boat |
|---|---|---|---|
| Isolation | Firecracker microVM per sandbox, own kernel | Secure container sandboxing inside your Google Cloud project | Full VM, own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| Root and Docker | Root, and Docker with a Docker-in-sandbox image | Runs as appuser with no sudo; images must not need root; no Docker documented | Root, systemd and Docker on every machine |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | No /dev/kvm documented | Yes: /dev/kvm, so Android emulators and VMs run inside |
| Shell access | Terminal through bl connect; no native SSH | execute_bash() API calls, each in a new shell; no SSH | Real SSH, plus an API for commands |
| Sleep and wake | Standby seconds after the last connection, wakes in under 25 ms with memory and processes | Pause keeps the file system and costs less; no idle auto-stop | Stop keeps the disk and costs nothing; resume boots the VM again |
| Memory snapshots and fork | Fork with memory and running processes (private preview) | Snapshots keep memory and files; start many sandboxes from one | Fork a running sandbox (disk); no memory snapshots |
| Files and lifetime | Files in memory (about half the RAM) plus one volume; Tier 0 and 1 delete sandboxes after 7 or 30 days | Sandbox is deleted when its TTL ends: 7 days for a custom container, 14 for Code Execution | A real disk snapshotted every minute; no session cap on paid plans |
| Desktop and computer use | Desktop and browser with computer use | A browser with a VNC live view, a click and type API, and CDP | 60fps desktop and Chromium, computer use and an embeddable stream |
| Reaching the sandbox | Preview URL per port, public or token-protected; no raw TCP or public IP | Through Google's API or a private endpoint in your VPC; no public URL documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; own IPv6 or IPv4 |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | Off unless the template turns it on; route through your VPC with Cloud NAT, Cloud NGFW or Secure Web Proxy | Open internet; filter inside the VM with nftables |
| Keeping keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests (public preview) | You provision and scope the credentials the agent uses | AI credentials proxy for model providers and any HTTPS API you register |
| Agents | Claude Code image you drive from its terminal or your own harness | Hosts ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; Managed Agents API (Preview) runs Antigravity | Claude Code, Codex, OpenCode and more, driven by a prompt, steer and events API |
| CPU speed (Node.js build-and-test) | 19.48 runs per second | Not measured | 26.69 runs per second |
| Regions | Oregon, North Virginia, London, Frankfurt | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Blaxel | Google Agent Runtime | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | No | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | No | No | 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 | No | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | 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 | 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 | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
In StarSling's run of September 29, 2026, at 4 vCPU and 8 GB, boat did 26.69 Node.js build-and-test runs per second and Blaxel 19.48, so boat got about 1.4 times the work done in the same time. Google Agent Runtime and its sandboxes were not part of that run, so there is no comparable number for Google.
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). Google Agent Runtime 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 | Google Agent Runtime, 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 | $73 · 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 | $301 · Pay as you go | $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 | $3,626 · 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 | $1,030 · Pay as you go | $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 | $2,060 · Pay as you go | $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.
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, with the first 50 vCPU-hours and 100 GiB-hours free each month. Sandboxes are billed while they exist, and disk and egress rates are not published.
Google Agent Runtime: 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, counting those in standby, so the 300-user and 1,000-job scenarios need a sales tier. Google has no Docker inside its sandboxes, so the 50-agent fleet does not fit, and every Google row leaves disk and egress unpriced because those rates are not published. On boat the 1,000-job burst is the problem: starts are capped per minute and per day, so the jobs get queued.
| Scenario | Blaxel | Google Agent Runtime | 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 agents need root and Docker in a sandbox that sleeps when idle and wakes in milliseconds with its memory, or must run in the US.
- Root and Docker in every sandbox. Useful if your agents install packages or build containers: Blaxel gives root and runs Docker, which Google's sandboxes do not.
- Sleeps in seconds, wakes in milliseconds. Useful if sandboxes sit idle most of the time: one goes to standby after the last connection and wakes in under 25 ms.
- Previews people can open. Useful if users need to see what an agent built: each port can get a public or token-protected preview URL.
Use Google Agent Runtime when
you build agents with ADK or LangGraph on Google Cloud and want them hosted inside your own project, network rules and regions, with short code runs in a locked sandbox.
- A managed home for your agent code. Useful if you build agents with ADK or LangGraph: Agent Runtime hosts them and does not bill idle time between turns.
- Inside your Google Cloud network. Useful if agents must stay in your Google Cloud perimeter, with egress off by default and routed through your own firewall.
- Regions worldwide. Useful if you need to run in Asia, Canada, Australia or Brazil: Google offers 23 locations.
Where boat fits
If your agents do real work for hours, like builds, tests, Docker and emulators, both options make you work around them: Blaxel keeps files in memory and has no SSH, and Google takes away root and Docker. boat gives each agent a whole Linux VM with a real disk, a faster CPU than Blaxel's, and coding agents you drive from outside.
A whole Linux machine
boat has root, systemd, SSH, Docker and /dev/kvm. Blaxel has no /dev/kvm, so Android emulators do not start, and no native SSH. Google has no sudo or Docker, so you bake every tool into an image ahead of time.
A disk that stays, with no session cap
Blaxel keeps files in about half the RAM unless you attach a volume at creation, and its lower tiers delete sandboxes after 7 or 30 days. Google deletes a custom container sandbox after 7 days, so a long-lived agent must be recreated.
Public ports and agents driven from outside
boat serves HTTPS on up to 50 ports and raw TCP, where Blaxel has no raw TCP and Google needs your own VPC endpoint or tunnel. Claude Code and Codex come installed with a prompt, steer and events API.
Use boat when your agents do real work for hours: builds, tests, Docker and emulators on a whole Linux machine with a real disk, SSH, public ports, a faster CPU and coding agents built in. Compare it one to one: boat vs Blaxel and boat vs Google Agent Runtime.
Questions people ask
Is Blaxel cheaper than Google Agent Runtime?
In all five scenarios we priced, yes: one coding agent on workdays comes to $33 a month on Blaxel and $73 on Google, and one agent running all month to $120 against $301. 50 agents in parallel come to $1,489 against $3,626, though Google cannot run that fleet without Docker. On boat the same two come to $20 and $26.
Which is faster, Blaxel or Google Agent Runtime?
Only Blaxel has a comparable measurement: 19.48 Node.js build-and-test runs per second at 4 vCPU and 8 GB. Google was not part of that run. boat did 26.69 in the same run.
Can Blaxel or Google Agent Runtime run Docker?
Blaxel can, with its Docker-in-sandbox image. Google's sandboxes run as the unprivileged user appuser with no sudo, and custom images must not need root, so Docker is not available. boat runs Docker, systemd and /dev/kvm on every VM.
Is Google Agent Runtime the same as Vertex AI Agent Engine?
Yes. Google renamed Vertex AI Agent Engine to Agent Runtime in April 2026, as part of Gemini Enterprise Agent Platform. The code, shell and browser sandboxes are a separate part called Agent Sandbox.
Do Blaxel and Google keep a sandbox's memory?
Both can. Blaxel saves memory and running processes in standby and wakes in under 25 ms, and Google snapshots keep memory and files so you can start many sandboxes from one. boat keeps the disk and reboots on resume.
Where do Blaxel and Google Agent Runtime run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. Google runs in 23 locations across the US, Europe, Asia, Canada, Australia and Brazil. boat runs only in the EU, in Germany, Finland and France, with EU data residency.
Try boat
Install the CLI, then run boat new.
7-day free trial