Koyeb vs Google Agent Runtime
Koyeb runs each sandbox as a microVM from any Docker image, with a public HTTPS port, GPUs and scale to zero. Google Agent Runtime hosts your agent code on Google Cloud and gives it sandboxes that run as an unprivileged user inside your own project, with no public URL.
The companies and products
Koyeb
Koyeb is a serverless cloud for apps, inference and sandboxes, and in February 2026 it agreed to join Mistral AI.
A Koyeb sandbox is a Koyeb service: a microVM started from any Docker image and driven from Python or JavaScript SDKs that run commands, read files and expose a port. It can scale to zero when idle and wake on the next request, and it can run on CPU or GPU instance types. It is built for teams that run AI agents or untrusted code next to apps they already host on Koyeb.
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. “4th cheapest of 345” means 3 of the other 344 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 | Koyeb: 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 Koyeb ranks 54th and Google Agent Runtime ranks 295th, because Google's sandboxes have no root or Docker; bochka ranks 3rd with Docker, systemd and a disk that stays. | 54th of 367, with limits $366 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 Agent Runtime ranks 28th here since its Runtime hosts agents and skips billing between turns, while a sandbox still ends at its 7-day TTL; bochka ranks 5th with no session cap on paid plans. | 135th of 366, with limits $923 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 Koyeb ranks 4th for short code runs, with small instances that sleep when idle and wake on a request, while Google offers a ready Python interpreter sandbox with no network. | 4th cheapest of 345 $66 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 Koyeb ranks 6th because each sandbox can expose an HTTPS port to your users, while Google sandboxes are reached only through its API or a private endpoint; bochka ranks 1st with HTTPS on up to 50 ports. | 6th cheapest of 361 $495 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 | 237th of 360, with limits $1,631 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 | 19th cheapest of 364 $429 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 Neither fits CI that builds images well: Google has no Docker inside its sandboxes and Koyeb does not document /dev/kvm, while bochka ranks 4th with both. | 142nd of 377, with limits $88 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 | 217th of 368, with limits $37 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 Google gives agents a browser with a VNC view and a click and type API, Koyeb has no browser or desktop, and bochka ranks 6th with a 60fps Linux desktop. | 81st of 369, with limits $123 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 | 172nd of 367, with limits $123 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 Google Agent Runtime ranks 53rd with a real Chromium over CDP and static egress IPs through your VPC, against 172nd for Koyeb, where you run a headless browser yourself. | 172nd of 346, with limits $89 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 | 65th of 338, with limits $1,683 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 | 233rd of 360, with limits $299 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 Koyeb ranks 3rd here with GPU instances up to H100 and H200, and neither Google's sandboxes nor bochka offer GPUs. | 3rd cheapest of 98 $628 a month | 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 | Koyeb | Google Agent Runtime | bochka |
|---|---|---|---|
| Isolation | MicroVM per instance | Secure container sandboxing inside Google Cloud | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and /dev/kvm | Starts from any Docker image; nested virtualization not documented | 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 machine |
| Reaching the sandbox from outside | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | 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 IPv4 or IPv6 |
| Shell access | Run commands through the Python or JavaScript SDK | execute_bash() API calls; each command runs in a new shell; no SSH | SSH, plus an API for commands |
| Desktop and browser | No desktop or browser in the sandbox SDK | A browser in a container with a VNC live view, a click, type and screenshot API, and CDP | 60fps Linux desktop with Chromium and computer use |
| Files after a stop | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, two regions) persist | Pause keeps the file system; the sandbox is deleted when its TTL ends | Disk kept across stops and saved every minute; a stopped sandbox costs nothing |
| Snapshots and branching | SDK snapshots of files or running processes, then new sandboxes from them (experimental) | Snapshots keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox with its disk; resume reboots from disk |
| How long a sandbox lives | No forced cap; optional auto-delete timers | TTL of up to 7 days for a custom container and 14 days for Code Execution | No session cap on paid plans |
| Sleep and wake | Scales to zero after 5 idle minutes and wakes on the next request | Runtime skips billing between turns; sandboxes are billed while they exist | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Hosting your agent code | A serverless cloud for apps and inference next to your sandboxes | Agent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents | You run your own agent loop inside a sandbox, with HTTPS hosting on its ports |
| Coding agents | Tutorials that run agents through the command API; an MCP server to manage Koyeb | Managed Agents API (Preview) runs Google's Antigravity harness | Claude Code, Codex and five other agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are set as environment variables inside the service | 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 |
| Outbound rules | Block all outbound traffic, or allow only listed IPs and CIDRs | 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 |
| GPUs and regions | GPUs from RTX 4000 SFF Ada up to H100 and H200; EU, US and Asia | No GPU sandboxes; 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | No GPUs; EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Koyeb | Google Agent Runtime | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | No | Yes |
| Systemd | Not published | 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 | Yes | Yes | Yes |
| Live fork (no pause) | Not published | 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 | Yes | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Koyeb or for Google Agent Runtime: neither was part of the hpc-sandbox-benchmarks run. bochka did 26.69 Node.js build-and-test runs per second there at 4 vCPU / 8 GB. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores, so its speed depends on how busy the host is.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Koyeb 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 | Koyeb, 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 | $29 · 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 | $57 · Pro | $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 | $475 · 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 | $329 · Scale | $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 | $485 · Scale · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
Koyeb: Koyeb bills each instance per second at a fixed price per instance type, and a deep-sleeping sandbox costs nothing. Pro costs $29 a month with $10 of usage included and Scale $299 with $100 included; the rest of the fee is not credit.
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 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
Koyeb's priced shape is eco-xlarge, with a 20 GiB disk and no published price for more, and eco instances guarantee only half of each vCPU, which is why its 1,000-job burst does not fit. Google cannot run the 50-agent fleet because its sandboxes have no Docker inside, and every Google row leaves disk and egress unpriced. bochka does not fit the burst either: starts above 90 a minute and 2,400 a day are queued on the $2,000 plan.
| Scenario | Koyeb | 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 |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Koyeb when
your sandboxes start from your own Docker image, need a public port, GPUs or regions in the US and Asia, and sleep between requests.
- A public port and your own image. Good for sandboxes your users open in a browser: Koyeb starts any Docker image and exposes an HTTPS port.
- Sleep when idle, wake on request. Good for sandboxes that sit idle between requests: Koyeb scales to zero after 5 minutes and wakes on the next one.
- GPUs in the same platform. Useful when an agent or eval needs a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
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, with short code runs and a browser 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.
- A browser and an interpreter ready to use. Useful for agents that browse or run Python: Google ships a Computer Use browser and a Code Execution sandbox.
- Inside your Google Cloud network. Useful if agents must stay in a Google Cloud perimeter, with egress off by default and memory snapshots to branch from.
Where bochka fits
Koyeb and Google Agent Runtime both give an agent a place to run code, but neither gives it a whole computer to work on for days. If your agents install tools, run Docker, use a desktop and show what they build, bochka gives each one a full VM that keeps its disk, with coding agents and hosting built in.
Root, Docker and /dev/kvm
Google's sandboxes run as appuser with no sudo, so apt installs and Docker builds fail there. Koyeb starts from Docker images but documents no /dev/kvm, so Android emulators and VMs must run elsewhere.
A disk that stays and a machine with no TTL
On Koyeb the local disk is lost on redeploy unless you add a preview volume of 1 to 10 GB. A Google sandbox is deleted when its TTL ends, 7 days at most for a custom container, so long-lived agents need rebuilding.
Desktop, ports and agents built in
Koyeb has no desktop and one public port at a time, and Google has a browser but no public URL. bochka streams a 60fps desktop, serves HTTPS on 50 ports and ships Claude Code and Codex with keys kept outside.
Use bochka when your agents need a real computer for hours or days: root, Docker, SSH, a desktop and public URLs on a full VM that keeps its disk, with coding agents built in. Compare it one to one: bochka vs Koyeb and bochka vs Google Agent Runtime.
Questions people ask
Is Koyeb cheaper than Google Agent Runtime?
In our scenarios, yes: one agent that never stops comes to $57 a month on Koyeb against $301 on Google, and sandboxes for your users $329 against $1,030. bochka comes to $26 and $200 for the same two. Google's numbers assume a sandbox that exists all those hours.
Which is faster, Koyeb or Google Agent Runtime?
We have no comparable CPU measurement for either. bochka did 26.69 runs per second on the Node.js benchmark at 4 vCPU / 8 GB. Koyeb guarantees at least 0.25 dedicated vCPU per GB of memory and bursts above that.
Can Koyeb or Google Agent Runtime run Docker?
Koyeb starts each sandbox from any Docker image in a microVM, but does not document /dev/kvm. Google's sandboxes run as appuser with no sudo, and custom images must not need root, so Docker is not available there. bochka gives every sandbox root, Docker, systemd and /dev/kvm.
Can I show a web app an agent built?
On Koyeb you can expose one HTTPS port at a time, plus a TCP proxy to one port. Google's docs describe reaching a sandbox through its API or a private endpoint in your VPC, not a public URL. bochka serves HTTPS on up to 50 ports with raw TCP too.
Which one has GPUs or a browser?
Koyeb has GPU instances up to H100 and H200 but no browser in its sandboxes. Google has a Computer Use browser sandbox and no GPU sandboxes. bochka has a 60fps desktop with Chromium and no GPUs.
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 sandboxes are a separate part of the same platform called Agent Sandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview