Sprites vs Google Agent Runtime
Sprites, from Fly.io, gives each agent a persistent Firecracker microVM with root and Docker that sleeps when idle and wakes on the next request. Google Agent Runtime, once called Vertex AI Agent Engine, hosts your agent code on Google Cloud and runs code in sandboxes as an unprivileged user with no sudo.
The companies and products
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
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. “63rd cheapest of 377” means 62 of the other 376 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 | Sprites: 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 Sprites gives root and Docker on a disk that stays, while Google's sandboxes have no sudo or Docker; bochka adds systemd, /dev/kvm and up to 50 public ports. | 66th of 367, with limits $546 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 Google keeps a sandbox running until its TTL ends (7 days at most for a custom container), while a Sprite pauses about 30 seconds after work stops unless a task holds it awake; bochka just keeps running. | 157th of 366, with limits $1,166 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 fit short code runs: a Sprite sleeps and bills only real CPU and memory, and Google's Code Execution sandbox is a ready Python interpreter with no network. | 93rd of 345, with limits $140 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 A Sprite gives each user one HTTPS URL that wakes it, while a Google sandbox has no public URL documented; bochka gives each user SSH, raw TCP and HTTPS on up to 50 ports. | 56th of 361, with limits $428 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 | 105th of 360, with limits $6,540 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 | 125th of 364, with limits $545 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 CI that builds containers needs Docker, which runs on Sprites and bochka but not in Google's unprivileged sandboxes; only bochka exposes /dev/kvm for emulator builds. | 63rd cheapest of 377 $476 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 gives you plain SSH: Sprites tunnels it through its CLI and Google runs each command in a new shell; bochka has SSH, systemd and a desktop. | 213th of 368, with limits $27 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 Sprites is headless, Google gives you a browser with a VNC view and a click and type API, and bochka streams a full 60fps desktop with Chromium. | 85th of 369, with limits $136 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 Google runs a real Chromium you drive over CDP; on Sprites you install a headless browser yourself, and bochka ships Chromium on a desktop you can watch. | 171st of 367, with limits $122 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 | 229th of 346, with limits $206 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 | 141st of 338, with limits $4,113 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 | 210th of 360, with limits $223 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 | Sprites | Google Agent Runtime | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Secure container sandboxing inside Google Cloud | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root and Docker | Root and Docker, with rough edges users report; no systemd, no /dev/kvm in the docs | Runs as appuser with no sudo; images must not need root; no Docker documented | Root, systemd, Docker and /dev/kvm on every machine |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory managed by the platform | Runtime: up to 8 vCPU and 32 GiB; sandbox maximum not published | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Idle behavior | Pauses about 30 seconds after work stops and wakes on the next request | Runtime skips billing idle time between turns; sandboxes bill while they exist, less when paused | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing |
| How long a sandbox lives | No published cap; a task hold keeps it awake for up to an hour at a time | TTL of up to 7 days for a custom container and 14 days for Code Execution | No session cap on paid plans |
| Snapshots and fork | Filesystem checkpoints that restore in place; no fork | Snapshots keep memory and files; start many sandboxes from one snapshot | Disk saved every minute and on stop; fork a running sandbox (no memory snapshots) |
| Reaching the sandbox | One HTTPS URL to one HTTP port; other ports and SSH through the sprite proxy CLI | 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 IP; SSH |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Off unless the template turns it on; route through your VPC with Cloud NAT, a static IP or a firewall | Open internet, no provider-side allowlist |
| Desktop and browser | Headless; no desktop or browser product | A browser in a container with a VNC live view, a click and type API, and CDP | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Managed Agents API (Preview) runs Google's Antigravity harness | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping keys out of the sandbox | Connectors gateway holds tokens for any HTTP API, with path allow and block lists | 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 | You run your agent inside a Sprite; plugs into Claude Managed Agents and Cursor Cloud Agents | Deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents as a managed service | You run your own agent loop inside a sandbox |
| Regions | Region not selectable | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | 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 | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | 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 | No | 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 | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | 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 | Yes | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Sprites or for Google Agent Runtime: neither is in the hpc-sandbox-benchmarks results we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites 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 | Sprites, 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 | $23 · Pay-as-you-go | $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 | $92 · Pay-as-you-go | $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,120 · Pay-as-you-go | $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 | $314 · Pay-as-you-go · 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,134 · Pay-as-you-go · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills CPU time actually used at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans buy fixed CPU, memory and storage allowances that are not credit.
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 bill while they exist, and the paused, disk and egress 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
Sprites does not publish how many machines can run at once on pay as you go, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed. Google cannot run the 50-agent fleet because its sandboxes have no Docker inside, and every Google row leaves disk and egress unpriced. A Google sandbox is deleted when its TTL ends, while a Sprite needs a task hold renewed each hour to stay awake. bochka has no session cap on paid plans, but at 1,000 short jobs at once its starts are queued above 90 a minute and capped at 2,400 a day.
| Scenario | Sprites | Google Agent Runtime | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| None that bite |
| One agent that never stops | None that bite |
| 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 Sprites when
your agents need root and Docker in their own VM, sit idle most of the day and should wake on a request.
- Root and Docker in a real VM. For agents that run apt installs or Docker builds, a Sprite gives root inside its own microVM, which Google's sandboxes do not.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day, a Sprite stops billing compute and wakes on the next request in under a second.
- Coding agents and a public URL. For teams using Claude Code or Codex, Sprites has them preinstalled and gives each machine an HTTPS URL to show what it built.
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.
- A managed home for your agent code. For agents built with ADK or LangGraph, Agent Runtime hosts them and skips billing 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.
- Memory snapshots and regions worldwide. For branching a sandbox with its memory, or running in the US or Asia, Google offers both across 23 locations.
Where bochka fits
If your agents need a whole computer for hours, both options leave gaps: Sprites has no systemd, desktop or second public port, and Google's sandboxes have no root, Docker or public URL. bochka gives every agent a full VM with root, systemd, Docker, /dev/kvm, a 60fps desktop and HTTPS on up to 50 ports, with no session cap on paid plans.
A machine that runs anything
On Google, sudo apt install and docker compose fail, so you bake every tool into an image. On Sprites, Docker works but systemd units need rewriting as Sprite services and emulators have no /dev/kvm. bochka runs all of it.
Agents that keep working
A Sprite pauses about 30 seconds after work stops and drops open connections, so a long task needs an hourly hold. A Google sandbox is deleted when its TTL ends. A bochka VM runs until you stop it, and its disk is saved every minute.
A screen, ports and agents you drive
Sprites is headless and Google gives only a browser, so desktop apps are out of reach. bochka streams a 60fps desktop, serves HTTPS on 50 ports, and lets you prompt and steer Claude Code or Codex from outside.
Use bochka when your agents need a full machine for hours: systemd, Docker, /dev/kvm, a desktop, public ports, forks, and coding agents you drive from outside. Compare it one to one: bochka vs Sprites and bochka vs Google Agent Runtime.
Questions people ask
Is Sprites cheaper than Google Agent Runtime?
In our scenarios, yes: one coding agent on workdays comes to $23 a month on Sprites and $73 on Google, and one agent that never stops is $92 versus $301. 50 agents in parallel come to $1,120 on Sprites, and Google cannot run that fleet without Docker. bochka comes to $20, $26 and $317 for the same three.
Which is faster, Sprites or Google Agent Runtime?
We have no comparable CPU measurement for either one. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in the benchmark we use.
Can Sprites and Google Agent Runtime run Docker?
Sprites runs Docker with root, though users report that docker exec fails for containers whose main process is not root. Google's sandboxes run as the unprivileged user appuser with no sudo, so Docker is not available. bochka runs Docker, systemd and /dev/kvm in every sandbox.
How long can a sandbox run on each?
A Sprite has no published time cap but pauses about 30 seconds after work stops, unless a task holds it awake for up to an hour at a time. A Google sandbox is deleted when its TTL ends, 7 days at most for a custom container. 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 called Agent Sandbox.
Where do Sprites, Google and bochka run?
Sprites does not let you choose a region. 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