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.

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 workloadBlaxel: price rankGoogle Agent Runtime: price rankboat: 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 requirementNot ranked: misses a requirementNot 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 requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureBlaxelGoogle Agent Runtimeboat
IsolationFirecracker microVM per sandbox, own kernelgVisor-isolated container in a Google-managed tenant projectFull VM with its own kernel, on hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
Root and DockerRoot, and Docker with a Docker-in-sandbox imageRuns as appuser with no sudo; images must not need root; Docker inside not documentedRoot, systemd and Docker on every machine
Nested virtualizationNot documented; upstream Firecracker does not give guests /dev/kvmNot documentedYes: /dev/kvm, so Android emulators and VMs run inside
Shell accessTerminal through bl connect; SSH through Tailscale (documented tutorial)execute_bash() API calls, each in a new shell; SSH not documentedBuilt-in SSH, plus an API for commands
Sleep and wakeStandby about 5 to 15 seconds after the last connection; wakes in under 25 ms with memory and processesPause keeps the file system at a lower, unpublished rate; no idle auto-stopAuto-stop timer (default 1 hour), not idle detection; resume boots the VM again
Memory snapshots and forkFork with memory and running processes (private preview)Snapshots (Preview) keep memory and files; start many sandboxes from oneFork a running sandbox from its last 1-minute snapshot (disk only); no memory snapshots
Files and lifetimeWritable 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 daysSandbox is deleted when its TTL ends (7 days for a custom container, 14 for Code Execution); a snapshot carries state into a new sandbox51 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 useDesktop image with VNC and a browserA browser with a VNC live view, a click, type and screenshot API, and CDP; a full desktop is not documented60 fps desktop and Chrome, computer use and an embeddable stream
Reaching the sandboxPreview URL per port, public or token-protected; no public inbound IPThrough Google's API or a private endpoint in your VPC; a public URL is not documentedSSH, up to 50 HTTPS URLs per sandbox (token-gated by default), raw ports over public IPv6
Outbound rulesDomain 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 ProxyOpen internet; filter inside the VM with nftables
Keeping keys out of the sandboxProxy fills secrets into outbound HTTPS requests to any host (public preview)You provision and scope the credentials the agent usesOptional AI credentials proxy ($1 a day plus $1 per 1,000 requests) for model providers and HTTPS APIs you register
AgentsClaude Code and Codex images you drive from their terminal or your own harnessHosts ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; Managed Agents API (Preview) runs AntigravitySeven 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 run28.06 runs/s, 2nd of 15 (shared), on a Ryzen 9 9950X host
RegionsOregon, North Virginia, London, Frankfurt23 locations in the US, Europe, the Middle East, Asia, Canada, Australia and BrazilGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureBlaxelGoogle Agent Runtimeboat
Full VM (own kernel)YesNo documented wayYes
Docker insideYesNo documented wayYes
Nested virtualizationNo documented wayNo documented wayYes
RootYesNo documented wayYes
SystemdNo documented wayNot publishedYes
Desktop GUIYesNot publishedYes
BrowserYesYesYes
Computer-use APIYesYesYes
SSHWith your own setupNo documented wayYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
Fork/cloneYesYesYes
Live fork (no pause)YesYesYes
Memory forkYesYesNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesNo documented wayNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesNo documented wayYes
Raw TCP inboundNo documented wayNot publishedYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesNo documented wayYes
Secret proxy for any APIYesNo documented wayYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayYesYes
MCP serverYesNo documented wayNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayYesNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCYesNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysYesNot publishedYes
Spend limitsNo documented wayNot publishedYes
Usage per sandbox (API)YesYesYes
Audit logsNot publishedNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionYesNot publishedYes

Performance

Blaxel18.03 runs/s
Google Agent RuntimeNot measured
boat28.06 runs/s

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.

ScenarioBlaxel, a monthGoogle Agent Runtime, a monthboat, 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.

ScenarioBlaxelGoogle Agent Runtimeboat
One coding agent, workdaysNone for this scenario
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
One agent that never stopsNone for this scenario
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
50 agents in parallelNone for this scenario
  • missing Docker inside
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
Sandboxes for your users
  • Pay-as-you-go Tier 2: max 200 concurrent
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
1,000 short jobs at once
  • Pay-as-you-go Tier 2: max 200 concurrent
  • disk beyond 0 GiB: price unknown
  • egress price not published
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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

More comparisons