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, once called Vertex AI Agent Engine, hosts your agent code inside Google Cloud, and its Agent Sandbox runs tools in gVisor-isolated 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. 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. It goes 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 keep 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. Each sandbox runs in a gVisor-isolated container in a Google-managed tenant project. Teams on GKE can also run the open-source GKE Agent Sandbox in their own cluster, with gVisor or Kata Containers, and manage it themselves.
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. “15th cheapest of 365” means 14 of the other 364 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 with root and Docker. Google's sandboxes run without root and document no Docker; you bake tools into a custom image and run Docker builds elsewhere. boat adds /dev/kvm for emulators and a 51 GB disk. | 15th cheapest of 365 $2,373 a month | 310th of 365, with limits $5,801 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 17th cheapest of 361 $2,832 a month | 34th cheapest of 361 $7,519 a month | 6th cheapest of 361 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both fit: Blaxel sleeps short runs at once and wakes them in milliseconds, and Google's Code Execution sandbox is a ready Python and JavaScript interpreter with no network that bills only for use. | 18th cheapest of 336 $144 a month | 251st of 336, with limits $275 a month | 189th of 336, 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 self-serve tiers stop at 200 sandboxes at once. Google documents no public URL for a sandbox; users reach it through your own VPC. boat allows 300 at once from its $100 plan, with HTTPS on up to 50 URLs per sandbox. | 105th of 349, with limits $926 a month | 275th of 349, with limits $1,916 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 82nd of 349, with limits $4,378 a month | 132nd of 349, with limits $8,240 a month | 39th of 349, 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 evals without a sales call. Blaxel's self-serve tiers cap how many run at once at 200. boat starts a fresh VM per task from a saved snapshot, within its start limits. | 140th of 359, with limits $704 a month | 90th cheapest of 359 $2,060 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build containers need Docker. Blaxel runs it with its Docker-in-sandbox image. On Google you build images outside the sandbox and push them to Artifact Registry. | 55th cheapest of 374 $431 a month | 104th cheapest of 374 $989 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Blaxel gives a terminal through bl connect and documents SSH through Tailscale. Google documents no SSH, and each execute_bash() call runs in a new shell. boat gives you built-in SSH and a disk saved every minute. | 125th cheapest of 371 $114 a month | 317th of 371, with limits $241 a month | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Blaxel has a desktop image with VNC. Google's Computer Use sandbox runs a browser with a VNC live view and a click, type and screenshot API. boat streams a 60 fps desktop you can embed. | 17th cheapest of 367 $634 a month | 85th of 367, with limits $1,648 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 16th cheapest of 356 $317 a month | 132nd of 356, with limits $824 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 19th cheapest of 343 $215 a month | 56th cheapest of 343 $515 a month | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 143rd of 327, with limits $4,292 a month | 212th of 327, with limits $8,240 a month | 73rd of 327, 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 gives root and domain-level egress rules (public preview). Google's sandboxes run without root, with egress off unless the template turns it on. boat gives root and you filter with nftables. | 5th cheapest of 351 $217 a month | 281st of 351, with limits $412 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Blaxel | Google Agent Runtime | boat |
|---|---|---|---|
| Isolation | Firecracker microVM per sandbox, own kernel | gVisor-isolated container in a Google-managed tenant project | Full VM with its own kernel, on hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared |
| Root and Docker | Root, and Docker with a Docker-in-sandbox image | Runs as appuser with no sudo; images must not need root; Docker inside not documented | Root, systemd and Docker on every machine |
| Nested virtualization | Not documented; upstream Firecracker does not give guests /dev/kvm | Not documented | Yes: /dev/kvm, so Android emulators and VMs run inside |
| Shell access | Terminal through bl connect; SSH through Tailscale (documented tutorial) | execute_bash() API calls, each in a new shell; SSH not documented | Built-in SSH, plus an API for commands |
| Sleep and wake | Standby about 5 to 15 seconds after the last connection; wakes in under 25 ms with memory and processes | Pause keeps the file system at a lower, unpublished rate; no idle auto-stop | Auto-stop timer (default 1 hour), not idle detection; resume boots the VM again |
| Memory snapshots and fork | Fork with memory and running processes (private preview) | Snapshots (Preview) keep memory and files; start many sandboxes from one | Fork a running sandbox from its last 1-minute snapshot (disk only); no memory snapshots |
| Files and lifetime | Writable files in RAM (about half of it) plus one volume or Agent Drive (private preview); Tier 0 and Tier 1 delete sandboxes after up to 7 or 30 days | Sandbox is deleted when its TTL ends (7 days for a custom container, 14 for Code Execution); a snapshot carries state into a new sandbox | 51 GB disk on the default size, snapshotted every minute; no session cap once auto-stop is off; stopped disk kept at least 14 days |
| Desktop and computer use | Desktop image with VNC and a browser | A browser with a VNC live view, a click, type and screenshot API, and CDP; a full desktop is not documented | 60 fps desktop and Chrome, computer use and an embeddable stream |
| Reaching the sandbox | Preview URL per port, public or token-protected; no public inbound IP | Through Google's API or a private endpoint in your VPC; a public URL is not documented | SSH, up to 50 HTTPS URLs per sandbox (token-gated by default), raw ports over public IPv6 |
| Outbound rules | Domain allow and deny lists with method and path rules (public preview), dedicated egress IPs (free during beta) | 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 to any host (public preview) | You provision and scope the credentials the agent uses | Optional AI credentials proxy ($1 a day plus $1 per 1,000 requests) for model providers and HTTPS APIs you register |
| Agents | Claude Code and Codex images you drive from their terminal or your own harness | Hosts ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; Managed Agents API (Preview) runs Antigravity | Seven harnesses installed, including Claude Code and Codex, driven by a prompt, steer and events API |
| CPU benchmark (V8 Web Tooling, 4 vCPU / 8 GB, StarSling run of 3 October 2026) | 18.03 runs/s, rank 7 of 15 (shared) | Not in this run | 28.06 runs/s, 2nd of 15 (shared), on a Ryzen 9 9950X host |
| Regions | Oregon, North Virginia, London, Frankfurt | 23 locations in the US, Europe, the Middle East, Asia, Canada, Australia and Brazil | Germany, Finland and France; you cannot pick a region; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Blaxel | Google Agent Runtime | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No documented way | Yes |
| Docker inside | Yes | No documented way | Yes |
| Nested virtualization | No documented way | No documented way | Yes |
| Root | Yes | No documented way | Yes |
| Systemd | No documented way | Not published | Yes |
| Desktop GUI | Yes | Not published | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | With your own setup | No documented way | 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 documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No documented way | No documented way |
| Wake on request | Yes | No documented way | No documented way |
| HTTPS preview URLs | Yes | No documented way | Yes |
| Raw TCP inbound | No documented way | Not published | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | No documented way | Yes |
| Secret proxy for any API | Yes | No documented way | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | Yes | Yes |
| MCP server | Yes | No documented way | No documented way |
| GPU | No documented way | No documented way | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | Yes | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | Yes | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | No documented way | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Not published | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | Yes | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Yes | Not published | Yes |
Performance
In StarSling's run of 3 October 2026 (run 37073680030), the V8 Web Tooling Benchmark at 4 vCPU and 8 GB, Blaxel did 18.03 runs per second (rank 7 of 15, shared) and boat 28.06 (second of 15). Every boat sandbox in that run ran on an AMD Ryzen 9 9950X host; boat also places sandboxes on other hosts. Google Agent Runtime and its sandboxes are not in the public benchmarks we use, so we cannot say how they compare.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Blaxel measured on: Sandbox (active time, RAM-only pricing, CPU bundled). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Google Agent Runtime is not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| 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 | $8,800 · $2000/mo · with limits |
Blaxel: Blaxel charges $0.0000115 per GB of allocated RAM per active second, with CPU included: 8 GB comes with 4 cores, about $0.33 an hour. Active means a connection is open. In standby you pay only snapshot storage ($0.20 per GB-month), and volumes cost $0.12 per GB-month on their full size.
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, rounded to the second. The pricing page lists 50 vCPU-hours and 100 GiB-hours free each month but does not say they cover sandboxes, so our totals do not subtract them. Sandboxes bill while they exist; a paused one costs less at an unpublished rate. Disk, snapshot and egress rates are not published.
Google Agent Runtime: Plans cost $20, $100, $500 or $2,000 a month. The whole plan price comes back as VM time for that month, and it does not carry over. A default sandbox costs $0.036 an hour, billed per second while it runs, busy or idle. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07.
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 documents no Docker inside its sandboxes, so the 50-agent fleet does not fit as listed, and every Google row leaves disk and egress unpriced because those rates are not published. boat's plans allow 100 to 2,000 at once; at 1,000 jobs at once its $2,000 plan charges for starts above 90 a minute and refuses them above 270.
| Scenario | Blaxel | Google Agent Runtime | boat |
|---|---|---|---|
| One coding agent, workdays | None for this scenario |
| None for this scenario |
| One agent that never stops | None for this scenario |
| None for this scenario |
| 50 agents in parallel | None for this scenario |
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 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 a named US or European region.
- Root and Docker in every sandbox. Useful if your agents install packages or build containers inside the sandbox: Blaxel gives root and runs Docker.
- 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 gVisor 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, boat gives each agent a whole Linux VM with a disk saved every minute and coding agents you drive from outside. Blaxel keeps writable files in RAM, and Google's sandboxes run without root.
A whole Linux machine
boat has root, systemd, SSH, Docker and /dev/kvm. Blaxel does not document /dev/kvm, so Android emulators are not a supported path there. Google has no sudo and documents no Docker, so you bake every tool into an image ahead of time.
A disk with no session cap
Blaxel keeps writable files in RAM unless you attach a volume, and Tier 0 and Tier 1 delete sandboxes after up to 7 or 30 days. Google deletes a custom container sandbox after 7 days; a snapshot (Preview) carries its state into a new one. boat saves the disk every minute but does not keep memory across a stop.
Public URLs and agents driven from outside
boat serves HTTPS on up to 50 URLs per sandbox and raw ports over IPv6, where Google needs your own VPC endpoint. Claude Code and Codex come installed with a prompt, steer and events API. boat runs only in Germany, Finland and France.
Use boat when your agents do real work for hours: builds, tests, Docker and emulators on a whole Linux machine with a disk saved every minute, SSH, public URLs and coding agents installed. boat runs only in Germany, Finland and France, with no US or Asia region, and caps starts per plan. Compare it one to one: boat vs Blaxel and boat vs Google Agent Runtime.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
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 documents no Docker for that fleet. A Runtime agent that sits idle between turns bills less on Google. On boat the first two come to $20 and $26.
Which is faster, Blaxel or Google Agent Runtime?
We cannot say. Blaxel did 18.03 runs per second in StarSling's run of 3 October 2026, and Google is not in that run. boat did 28.06 in the same run, on an AMD Ryzen 9 9950X host.
Can Blaxel or Google Agent Runtime run Docker?
Blaxel can, with its Docker-in-sandbox image. Google's managed sandboxes run as the unprivileged user appuser with no sudo, custom images must not need root, and Google documents no Docker inside; you build images outside and push them to Artifact Registry. Teams on GKE can also run the open-source GKE Agent Sandbox in their own cluster. 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. Google snapshots (Preview) 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, the Middle East, Asia, Canada, Australia and Brazil. boat runs on machines in Germany, Finland and France, and you cannot pick a region.
Try boat
Install the CLI, then run boat new.
7-day free trial