E2B vs Google Agent Runtime
E2B is a sandbox API: each agent gets a Firecracker microVM with root and Docker that pauses with its memory and wakes on the next request. Google Agent Runtime, once called Vertex AI Agent Engine, hosts your agent code on Google Cloud and gives it sandboxes that run as an unprivileged user with no sudo, inside your own project and network.
The companies and products
E2B
E2B calls itself the AI agent cloud: an API that gives each agent session its own isolated Linux machine.
Every E2B sandbox is a Firecracker microVM that boots from a snapshot, so it starts fast and can be paused and resumed with its memory. You build custom sandboxes from templates based on a Docker image, and drive them from Python or JavaScript SDKs. It is built for teams that run many short code, data or agent jobs, and its runtime is open source.
- Isolation
- Firecracker microVM per sandbox
- Bring your own cloud
- Enterprise data plane in your AWS, GCP or Azure account
- Compliance
- SOC 2 Type II; HIPAA BAA on request
- Machine size
- 1 to 8 vCPU and 1 to 8 GiB RAM, CPU only
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. “16th cheapest of 367” means 15 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 | E2B: price rank | Google Agent Runtime: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month E2B fits a software factory with root and Docker, while Google's sandboxes have no sudo or Docker; bochka adds no session cap, /dev/kvm and about twice E2B's CPU speed. | 16th cheapest of 367 $4,143 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 An assistant that lives all month hits E2B's 24-hour cap on Pro and Google's 7-day TTL for a custom container; a bochka VM has no session cap on paid plans. | 51st of 366, with limits $5,348 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 Both suit short code runs: E2B pauses with memory and wakes on the next request, and Google's Code Execution sandbox is a ready Python interpreter with no network. | 37th cheapest of 345 $421 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 E2B gives each user's sandbox an HTTPS URL per port, while Google documents no public URL; bochka serves HTTPS on up to 50 ports with token protection. | 23rd cheapest of 361 $2,354 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 E2B ranks 2nd here: memory forks of a running sandbox, up to 20 copies per call, suit many short rollouts that branch from one state. | 2nd cheapest of 360 $9,384 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 E2B and Google land close together here, and bochka's faster full VMs put it well ahead of both. | 78th cheapest of 364 $1,975 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 | 337th of 377, with limits $1,429 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 works well as a box you log into all month: E2B stops after 24 hours on Pro and Google has no SSH; bochka gives you SSH, a desktop and no session cap. | 192nd of 368, with limits $358 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 E2B has a Linux desktop for computer use, while Google gives only a browser with a VNC view; bochka streams a full 60fps desktop you can embed. | 32nd cheapest of 369 $1,342 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 | 100th of 367, with limits $746 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 | 57th cheapest of 346 $554 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 | 227th of 338, with limits $9,223 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 | 11th cheapest of 360 $1,043 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 | E2B | Google Agent Runtime | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Secure container sandboxing inside your Google Cloud project | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root and Docker | Root, systemd and Docker inside the sandbox | Runs as appuser with no sudo; images must not need root; no Docker documented | Root, systemd and Docker on every machine |
| Nested virtualization | Not supported | No /dev/kvm documented | Yes, /dev/kvm for Android emulators and VMs |
| CPU benchmark (4 vCPU / 8 GB) | 12.61 runs/s | Not measured | 26.69 runs/s |
| How long a sandbox lives | 1 hour on Hobby, 24 hours on Pro; pausing resets the clock | TTL of up to 7 days for a custom container, 14 days for Code Execution | No session cap on paid plans |
| Pause and memory | Pause saves memory and disk; resume in about 1 second with processes running | Snapshots keep memory and files; pause keeps the file system | Disk saved every minute and on stop; resume boots again from disk |
| Fork and branching | Fork a running sandbox with its memory, up to 20 copies per call | Start many sandboxes from one memory snapshot (same image and architecture) | Fork a running sandbox with its disk |
| Wake on request | A paused sandbox resumes on the next HTTP request or SDK call | Not offered for sandboxes | No; a stopped sandbox is started by API |
| Shell access | SSH and a command API | execute_bash() API calls; each command runs in a new shell; no SSH | SSH, plus an API for commands |
| Reaching the sandbox | HTTPS URL per port, public unless you turn on a token; no dedicated 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; dedicated IPv4 or IPv6 |
| Outbound internet | Open by default, with allow and deny lists by IP, CIDR or domain | Off unless the template turns it on; can route through your VPC with Cloud NAT, a static IP or Cloud NGFW | Open internet on every plan; no provider-side allowlist |
| Desktop and computer use | Linux desktop for computer use | A browser in a container with a VNC view, a click and type API, and CDP | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Agents and keys | Guides for many coding agents; secrets injected into outbound HTTPS headers (private beta) | Agent Runtime hosts ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; you scope the credentials | Seven coding agents preinstalled with a prompt, steer and events API; credentials proxy for any HTTPS API |
| Regions and hosting | US by default, EU and APAC on Pro; open-source runtime and bring your own cloud on Enterprise | 23 locations across the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | E2B | Google Agent Runtime | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | No | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | 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 | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's hpc-sandbox-benchmarks run of 2026-09-29, at 4 vCPU / 8 GB, bochka did 26.69 Node.js build-and-test runs per second and E2B did 12.61, so bochka did about twice the CPU work in the same time. Google Agent Runtime and its sandboxes were not part of that run, so there is no comparable measurement for them.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. 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 | E2B, a month | Google Agent Runtime, 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 | $202 · Pro | $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 | $368 · Pro · with limits | $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 | $2,773 · Pro | $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 | $1,395 · Pro+ (600 concurrent) | $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 | $2,797 · Pro++ (1,100 concurrent) | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
E2B: E2B bills per second for the vCPU and RAM you set, idle time included, until you pause or kill the sandbox. Pro costs $150 a month for higher limits with no usage credit, and more concurrency costs $500 a month per 500 slots.
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. Runtime skips idle time between turns, but sandboxes are billed while they exist, and disk, egress and paused rates are not published.
Google Agent Runtime: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
E2B caps a session at 24 hours on Pro, so it does not fit the agent that never stops, and Pro includes 20 GiB of disk. Google fits that one but deletes a custom container sandbox after 7 days, and it does not fit the 50-agent fleet because its sandboxes have no Docker inside; every Google row leaves disk and egress unpriced. bochka fits every scenario except the 1,000-job burst, where its starts per minute, hour and day are capped, while E2B Pro++ only queues bursts above 300 starts a minute.
| Scenario | E2B | Google Agent Runtime | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use E2B when
your agents need root and Docker for short jobs that pause between requests, branch with their memory, or must show a public URL.
- Root and Docker in every sandbox. For agents that run sudo apt install or docker compose, E2B gives root and Docker, which Google's sandboxes do not.
- Pause with memory and wake on request. For short jobs that sleep between requests, a paused E2B sandbox comes back in about a second with its processes running.
- Open source and public URLs. Its runtime is Apache-2.0, and each port can get an HTTPS URL, so users can open what an agent builds.
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. For agents built with ADK or LangGraph, Agent Runtime hosts them and skips billing for idle time between turns.
- Inside your Google Cloud network. For agents that must stay in a Google Cloud perimeter, egress is off by default and can route through your own firewall.
- Longer lives and more regions. A custom container sandbox can live up to 7 days, and it runs in 23 locations worldwide.
Where bochka fits
If your agents do real work for hours, with installs, builds, Docker, emulators and a browser, bochka gives each one a full VM that never cuts it off. E2B stops a session at 24 hours on Pro and Google deletes a sandbox when its TTL ends, and neither offers nested virtualization. bochka also ran the CPU benchmark about twice as fast as E2B.
A full VM with Docker and /dev/kvm
Google's sandboxes run as appuser with no sudo or Docker, so you bake every tool into an image. E2B has Docker but no nested virtualization, so Android emulators and VMs cannot start. bochka has root, Docker, systemd and /dev/kvm.
No session cap, disk kept for free
On E2B your code must pause and resume a task before 24 hours; on Google a sandbox is deleted after 7 days at most. bochka has no cap on paid plans, saves the disk every minute, and a stopped sandbox costs nothing.
Coding agents and keys handled for you
On E2B and Google you install Claude Code or Codex yourself and pass real keys into a machine the agent controls. bochka preinstalls seven agents you drive from outside, and its credentials proxy keeps keys out of the sandbox.
Use bochka when your agents do real work for hours: root, Docker, emulators, SSH, a desktop and public URLs on a fast full VM with no session cap and coding agents built in. Compare it one to one: bochka vs E2B and bochka vs Google Agent Runtime.
Questions people ask
Is E2B cheaper than Google Agent Runtime?
Mostly not in our scenarios: one coding agent on workdays comes to $202 a month on E2B and $73 on Google, and sandboxes for your users $1,395 versus $1,030. E2B is cheaper for 50 agents in parallel, $2,773 against $3,626, and Google cannot run that fleet without Docker. bochka comes to $20, $200 and $317 for those three.
Which is faster, E2B or Google Agent Runtime?
There is no comparable CPU measurement for Google's sandboxes. On the hpc-sandbox-benchmarks test at 4 vCPU / 8 GB, E2B did 12.61 runs per second and bochka did 26.69.
Can I run Docker in E2B or a Google Agent Sandbox?
E2B runs Docker inside the sandbox, with root. Google's shell sandbox runs commands as appuser with no sudo, and custom images must not need root, so Docker is not available. bochka has root, Docker and /dev/kvm on every VM.
How long can a sandbox run on each?
E2B stops a session after 24 hours on Pro and 1 hour on Hobby, though pausing resets the clock. Google deletes a sandbox when its TTL ends, up to 7 days for a custom container and 14 days for Code Execution. bochka has no session cap on paid plans.
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. Its code, shell and browser sandboxes are a separate part of the same platform called Agent Sandbox.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview