Runloop vs Google Agent Runtime
Runloop gives each coding agent a micro-VM devbox with root, Docker inside and SSH. Google Agent Runtime hosts agent code you build with ADK or LangGraph and adds sandboxes that run as an unprivileged user in a container inside your Google Cloud project.
The companies and products
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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. “20th cheapest of 367” means 19 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 | Runloop: 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 Runloop fits fully with root and Docker in its devboxes, while Google's unprivileged sandboxes cannot run sudo installs or docker compose; bochka adds /dev/kvm for emulators. | 20th cheapest of 367 $8,152 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 Both fit: Runloop can suspend an idle devbox and wake it on a request (Pro), and Google Runtime skips billing for idle time between turns; bochka has no session cap on paid plans. | 32nd cheapest of 366 $10,194 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 Runloop ranks above Google here, though Google's Code Execution sandbox is a ready Python interpreter with no network, and bochka's start limits queue very large bursts. | 44th cheapest of 345 $525 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 | 26th cheapest of 361 $3,301 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 Runloop ranks 4th for RL rollouts: it starts large waves without published start limits and sells RL fine-tuning on Enterprise. | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 Google prices CI lower, but builds that need Docker run on Runloop and bochka, not in Google's sandboxes; bochka's faster CPUs finish them sooner. | 121st cheapest of 377 $1,554 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 Runloop gives you SSH through a TLS proxy and Google gives you no SSH at all; bochka gives you SSH, a desktop and a dedicated IP. | 113th cheapest of 368 $410 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 Runloop ships a desktop your agent can control, while Google gives only a browser with a VNC view; bochka streams a full desktop at 60fps. | 39th cheapest of 369 $2,306 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 | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 Runloop fits with hostname allowlists per devbox, while Google's locked sandboxes are a compromise; bochka gives each run a full kernel with nested virtualization. | 10th cheapest of 360 $770 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 | Runloop | Google Agent Runtime | bochka |
|---|---|---|---|
| Isolation | Micro-VM on a custom bare-metal hypervisor, plus a container layer | Secure container sandboxing inside your Google Cloud project | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root and Docker inside | Yes, as root on the Docker-in-Docker blueprints | Runs as appuser with no sudo; images must not need root; no Docker | Root, systemd and Docker on every machine |
| Nested virtualization | Not documented | Not documented | Yes: /dev/kvm, Android emulator, VMs inside |
| Shell access | SSH through a TLS proxy, plus an API | execute_bash() API calls; each command runs in a new shell; no SSH | SSH, plus an API for commands |
| Images | Blueprints built from Dockerfiles, x86_64 and arm64 | Custom containers (Preview) that must not need root | Templates from named snapshots, x86_64 only, no Dockerfile builds |
| Snapshots and branching | Disk snapshots; start new devboxes from them | Snapshots keep memory and files; start many sandboxes from one | Disk saved every minute and on stop; fork a running sandbox |
| How long one lives | 1 hour by default, 48 hours max, or no cap with an idle policy | TTL of up to 7 days for a custom container, 14 days for Code Execution | No session cap on paid plans |
| Idle time | Suspend after idle and wake on an HTTP request (Pro plan) | Pause keeps the file system and costs less; Runtime skips idle time between turns | Stop costs nothing and keeps the disk; no idle timer |
| Reaching it from outside | One HTTPS tunnel per devbox, open or bearer token; no public IP | 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 IPv6 or IPv4 |
| Outbound network rules | Hostname allowlist with wildcards, or block all | Off unless the template turns it on; route through your VPC with Cloud NAT, static IP, Cloud NGFW or Secure Web Proxy | Open internet, no provider-side allowlist |
| Desktop and computer use | Desktop and browser your agent can control | A browser with a VNC view, a click and type API, and CDP | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents through Axons | Managed Agents API (Preview) runs Google's Antigravity harness | Claude Code, Codex, pi, OpenCode and more, with a prompt, steer and events API |
| Keeping API keys out | Agent gateways for any API endpoint | You provision and scope the credentials yourself | Credentials proxy for model providers and any HTTPS API; switch accounts when credits run out |
| Hosting agent code | Agents run inside devboxes | Deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents | You run your own agent loop inside a sandbox |
| Where it runs | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Runloop | 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 | Not published | 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 | No | 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 | Yes | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Yes | 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 | Not published | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On StarSling's Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29), bochka scored 26.69 runs a second and Runloop 8.29, about 3.2 times apart. Google Agent Runtime and its sandboxes were not part of that run, so there is no comparable number for Google. The test measures CPU work only, not start time or network speed.
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 | Runloop, 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 | $113 · Basic | $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 | $429 · Basic | $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 | $5,268 · Basic | $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,441 · Basic | $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 | $3,184 · Basic | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
Runloop: Runloop bills per second for the CPU and memory you allocate, while a devbox starts, runs, suspends or resumes, and bills its disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, rounded to the second, with the first 50 vCPU-hours and 100 GiB-hours free each month. Sandboxes are billed while they exist; disk, egress and paused rates are not published.
Google Agent Runtime: Plans start at $20 a month and the whole fee is usage credit, billed per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Google comes out lower in all five priced scenarios, but its rows leave disk and egress unpriced, and the 50-agent fleet does not fit because its sandboxes have no Docker inside. A Google sandbox is deleted when its TTL ends, 7 days at most for a custom container. Runloop's fixed lifetime tops out at 48 hours unless an idle policy replaces it, suspend needs Pro, and it publishes no egress price. bochka's limit is start rate: 1,000 jobs at once is queued even on the $2,000 plan.
| Scenario | Runloop | 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 Runloop when
your coding agents need root, Docker and SSH in a devbox, built from Dockerfiles or on arm64, or you want large waves of jobs or devboxes in your own AWS, GCP or Azure account.
- A real machine for coding agents. Useful if agents install packages and run Docker: Runloop devboxes give root, Docker-in-Docker and SSH, which Google's sandboxes do not.
- Dockerfiles, arm64 and your own cloud. Runloop builds images from Dockerfiles, offers arm64, and on Enterprise runs devboxes inside your AWS, GCP or Azure account.
- Large waves of short jobs. Useful for RL rollouts and evals: Runloop publishes no start limits and sells RL fine-tuning on its Enterprise plan.
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 agent code. Useful if you build agents with ADK or LangGraph: Agent Runtime hosts them and skips billing for idle time between turns.
- Inside your Google Cloud network. Useful if agents must stay in a Google Cloud perimeter, with egress off by default and routed through your own firewall.
- Memory snapshots and many regions. Google snapshots keep memory as well as files, so you can branch one sandbox many ways, in any of 23 locations.
Where bochka fits
If your agents do real work for hours, installs, builds, tests, Docker and emulators, look at bochka. Each sandbox is a full VM with its own kernel, keeps its disk on every plan and serves what the agent builds on public URLs. Runloop or Google still fit better for 1,000 jobs at once, hostname allowlists, or agent code hosted inside Google Cloud.
A full kernel with /dev/kvm
Google's sandboxes run as appuser with no sudo or Docker, and Runloop documents Docker-in-Docker but no /dev/kvm. On both, Android emulators and VMs do not start. bochka exposes /dev/kvm with root, systemd and Docker.
About three times the CPU speed
On the same Node.js build-and-test benchmark bochka ran 26.69 loops a second and Runloop 8.29, so builds and tests wait about three times longer on Runloop. Google's sandboxes were not measured.
Public ports and files that stay
Runloop gives one HTTPS tunnel and no raw TCP, and Google no public URL, so showing an agent's app means building your own route. Runloop drops the disk on shutdown and Google deletes a sandbox at its TTL; bochka keeps it on stop.
Use bochka when your agents need a real computer for hours: a full VM with root, Docker, /dev/kvm, SSH, a desktop and public URLs, on CPUs about three times faster than Runloop's, with files kept on every plan. Compare it one to one: bochka vs Runloop and bochka vs Google Agent Runtime.
Questions people ask
Is Runloop cheaper than Google Agent Runtime?
In our five scenarios Google comes out lower: one coding agent on workdays is $73 a month on Google and $113 on Runloop, and one agent running all month is $301 versus $429. But Google leaves disk and egress unpriced, and it cannot run the 50-agent fleet ($3,626 versus $5,268 on Runloop) because its sandboxes have no Docker. bochka comes to $20 and $26 a month for the first two.
Which is faster, Runloop or Google Agent Runtime?
There is no comparable CPU number for Google's sandboxes. Runloop scored 8.29 runs a second on StarSling's Node.js build-and-test loop at 4 vCPU / 8 GB, and bochka scored 26.69 on the same test.
Can Runloop or Google Agent Runtime run Docker?
Runloop can, as root on its Docker-in-Docker blueprints. Google's sandboxes run as the unprivileged user appuser with no sudo, and custom images must not need root, so Docker is out. bochka 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 of the same platform called Agent Sandbox.
How long can a sandbox run on each?
A Runloop devbox lives 1 hour by default and 48 hours at most, unless you set an idle policy, which has no documented cap. A Google sandbox is deleted when its TTL ends, 7 days at most for a custom container and 14 days for Code Execution. bochka has no session cap on paid plans.
Can I limit what a sandbox can reach on the internet?
Yes on both. Runloop lets a devbox reach only the hostnames you list, or nothing, and Google keeps egress off unless a template turns it on and can route it through your VPC firewall. bochka has open internet and no provider-side allowlist, so you filter inside the VM.
Try bochka
Install the CLI, then run bochka new.
Product preview