exe.dev vs Google Agent Runtime
exe.dev gives you Linux VMs with root, Docker and SSH that run until you stop them. Google Agent Runtime hosts agents you build with ADK or LangGraph on Google Cloud and gives them sandboxes that run as an unprivileged user in a locked container.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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. “15th cheapest of 366” means 14 of the other 365 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 | exe.dev: 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 | 253rd of 367, with limits $3,701 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 always-on assistants, with exe.dev ranked 15th and Google 28th, but a Google sandbox must be recreated when its TTL runs out; bochka ranks 5th with no session cap on paid plans. | 15th cheapest of 366 $3,833 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 Google's Code Execution sandbox is a ready Python interpreter, so it is the closer fit of the two for tiny code runs, though none of the three fits fully. | 235th of 345, with limits $175 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 exe.dev's Personal plan stops at 50 VMs at once and Google gives your users no public URL for what they build; bochka ranks 1st with HTTPS on up to 50 ports per sandbox. | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 agent evals and ranks 79th, ahead of exe.dev at 283rd, whose Personal plan stops at 50 VMs at once; bochka ranks 10th. | 283rd of 364, with limits $1,050 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 ranks 98th and exe.dev 288th for CI, but only exe.dev runs Docker inside for container builds; bochka ranks 4th and runs Docker on every VM. | 288th of 377, with limits $504 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 exe.dev ranks 25th for 24/7 dev boxes with root, SSH and a disk that lasts, while Google has no SSH and deletes a sandbox when its TTL ends; bochka ranks 18th and adds a desktop. | 25th cheapest of 368 $35 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 exe.dev VMs are headless and Google gives you only a browser with a VNC view, so desktop apps are out of reach on both; bochka streams a full 60fps desktop. | 240th of 369, with limits $1,055 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 | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 exe.dev ranks 60th and Google 260th for parallel red teaming; bochka ranks 2nd with a full VM, root and open internet on every sandbox. | 60th of 360, with limits $263 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 | exe.dev | Google Agent Runtime | bochka |
|---|---|---|---|
| Isolation | KVM VM with Cloud Hypervisor on rented bare-metal servers; you can't choose the kernel | Secure container sandboxing inside Google Cloud | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and nested virtualization | Root, systemd and Docker; /dev/kvm on Enterprise only | Runs as appuser with no sudo; images must not need root; no Docker or /dev/kvm documented | Root, systemd, Docker and /dev/kvm on every plan |
| Shell access | Brokered SSH | execute_bash() API calls; each command runs in a new shell; no SSH | SSH, plus an API for commands |
| Desktop and computer use | Headless; no desktop or screen streaming | A browser in a container with a VNC live view, a click, type and screenshot API, and CDP for Playwright | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Saved state | Disk persists and is streamed to a second server; no snapshots | Pause keeps the file system; the sandbox is deleted when its TTL ends | Snapshots every minute and on stop; a stopped sandbox costs nothing and resumes with its disk |
| Branching | cp copies a VM's disk and config into a new VM | Snapshots keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox; named snapshots as templates (no memory snapshots) |
| How long a machine lives | No cap; VMs run until you stop them | TTL of up to 7 days for a custom container and 14 days for Code Execution | No session cap on paid plans; you set the TTL |
| Custom images | Boot from your own Docker image in about two seconds | Custom container images (Preview) that must not need root | Templates from named snapshots; no Dockerfile or OCI images |
| Inbound traffic | HTTPS proxy for ports 3000 to 9999, one of them public; no public IP or raw TCP | Through Google's API or a private endpoint in your own VPC; no public URL documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Outbound internet | Open internet | Off unless the template turns it on; can route through your VPC with Cloud NAT, a static IP, Cloud NGFW or Secure Web Proxy | Open internet on every plan; no provider-side allowlist |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | Managed Agents API (Preview) runs Google's Antigravity harness | Claude Code, Codex, pi, OpenCode and three more, with a prompt, steer and events API and TypeScript and Python SDKs |
| Keeping keys out of the machine | Integrations inject secrets at the network edge for any HTTP host | You provision and scope the credentials the agent uses | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Hosting your agent code | No managed agent hosting; your agents run inside your VMs | Agent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billed | You run your own agent loop inside a sandbox |
| Regions | 9 regions in the US, Europe, Asia and Australia | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | exe.dev | Google Agent Runtime | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | No | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | 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 | No | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | 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 | 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 | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither exe.dev nor Google Agent Runtime is in StarSling's public hpc-sandbox-benchmarks run, so there is no comparable CPU measurement for either. In that run of 2026-09-29, bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. We don't guess how the other two would score.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev and Google Agent Runtime have 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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,848 · Personal | $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 | $530 · Personal · 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 | $1,050 · Personal · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
exe.dev: exe.dev Personal is a reserved pool with a flat monthly fee, from $15 for 2 vCPU / 4 GB up to $155 for 16 vCPU, billed whether its VMs are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour, and Work adds a team fee of $75 a month.
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour for what you allocate, with the first 50 vCPU-hours and 100 GiB-hours free each month. Sandboxes are billed while they exist, and disk, egress and paused rates are not published.
Google Agent Runtime: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal stops at 50 VMs at once, so the 300 user sandboxes and the 1,000 short jobs don't fit there. Google fits both of those but not the 50-agent fleet, because its sandboxes have no Docker inside, and every Google row leaves disk and egress unpriced. A Google sandbox is also deleted when its TTL ends, so an agent that never stops has to be recreated. On bochka the 1,000-job burst is the problem: starts are capped at 90 a minute and 2,400 a day on the $2,000 plan, so the jobs get queued.
| Scenario | exe.dev | 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 |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want persistent Linux VMs with root, Docker and SSH that boot from your own image, in regions around the world.
- A real VM you log into. Useful for dev boxes: exe.dev VMs have root, systemd, Docker and SSH, and run until you stop them.
- Your own Docker image. Useful if your setup lives in a Dockerfile: exe.dev boots each VM from your own image in about two seconds.
- A flat pool and an MCP server. A Personal pool is one flat monthly fee for VMs that stay on, and an MCP server lets tools like Claude Code control them.
Use Google Agent Runtime when
you build agents with ADK or LangGraph on Google Cloud and want them hosted inside your own project and network rules, 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 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 in 23 locations. Useful if you branch a sandbox with its memory, or need to run close to users in many countries.
Where bochka fits
If your agents need a whole computer for hours, look at bochka. Like exe.dev it gives each agent a full VM with root, Docker and SSH, and it adds what neither exe.dev nor Google has: a 60fps desktop, a snapshot every minute, public HTTPS on up to 50 ports and one API to drive coding agents inside from outside.
A screen your agents can use
exe.dev VMs are headless, so you set up and stream a desktop yourself. Google gives only a browser in a container, so an agent that must open a desktop app or check a native UI has nowhere to do it.
Work that is never lost
exe.dev has no snapshots, so one bad agent step can cost a whole session. Google deletes a sandbox when its TTL ends, 7 days at most for a custom container. bochka saves state every minute and has no session cap on paid plans.
Coding agents driven from outside
On exe.dev only Shelley takes prompts through the API, so you script shell sessions for Claude Code. Google runs only its Antigravity harness, in Preview, so you bake other agents into an image and pass keys in where sandbox code can read them.
Use bochka when your agents need a real computer for hours: root, Docker, a desktop and public URLs on a full VM that saves its state every minute, with coding agents you drive from outside. Compare it one to one: bochka vs exe.dev and bochka vs Google Agent Runtime.
Questions people ask
Is exe.dev cheaper than Google Agent Runtime?
In our five scenarios exe.dev's bill is lower every time: one agent running all month comes to $35 on exe.dev and $301 on Google, and 50 agents in parallel to $1,848 versus $3,626. But exe.dev's Personal plan can't run the 300-at-once and 1,000-at-once loads, and Google can't run the Docker fleet. bochka comes to $26 for the always-on agent and $317 for the fleet.
Which is faster, exe.dev or Google Agent Runtime?
We can't say, because neither was part of the public benchmark run we use. bochka scored 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
Can exe.dev or Google Agent Runtime run Docker?
exe.dev can: each VM has root, systemd and Docker. Google's sandboxes run commands as the unprivileged user appuser with no sudo, so Docker is not available there. bochka runs Docker 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.
Does either have a desktop for computer use?
exe.dev VMs are headless. Google offers a Computer Use sandbox with a browser, a VNC live view and a click and type API, but no full desktop. bochka streams a 60fps desktop with Chromium and has computer-use and browser-control APIs.
Where do exe.dev and Google Agent Runtime run?
exe.dev runs in nine regions in the US, Europe, Asia and Australia. Google runs in 23 locations across the US, Europe, Asia, Canada, Australia and Brazil. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview