GitHub Codespaces vs Google Agent Runtime
GitHub Codespaces is a cloud dev environment: a Linux dev container with Docker, opened from a repository, that stops after 12 hours at most. Google Agent Runtime, once called Vertex AI Agent Engine, hosts agent code on Google Cloud and gives it sandboxes that run as an unprivileged user with no Docker.
The companies and products
GitHub Codespaces
GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.
Codespaces is a different kind of product from boat: a dev environment for people working on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config, running on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.
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. “274th cheapest of 367” means 273 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 | GitHub Codespaces: price rank | Google Agent Runtime: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Codespaces has Docker and sudo but stops at 12 hours, and Google's sandboxes have neither root nor Docker; boat gives every VM root, Docker and /dev/kvm with no session cap on paid plans. | 274th of 367, with limits $4,618 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 fits an always-on assistant better, since a custom container sandbox lives up to 7 days against 12 hours for a codespace; a boat VM has no session cap on paid plans. | 309th of 366, with limits $6,970 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, while each codespace builds a dev container on a new VM, so Google is the better fit for short runs. | 288th of 345, with limits $619 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 Codespaces are made for GitHub users on a repository, and Google sandboxes have no public URL; boat can give each user sandbox HTTPS on up to 50 ports. | 281st of 361, with limits $1,964 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 | 282nd of 360, with limits $9,489 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 | 295th of 364, with limits $1,519 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 Codespaces can run Docker builds but has no fork or snapshot API, and Google can start many sandboxes from a memory snapshot but has no Docker inside. | 314th of 377, with limits $909 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 Codespaces is the better dev box of the two, with VS Code and SSH, though it stops after 12 hours; Google has no SSH and runs each command in a new shell. | 130th of 368, with limits $270 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 Codespaces has no graphical desktop, Google gives a browser with a VNC view and a click and type API, and boat streams a full 60fps desktop with Chromium. | 267th of 369, with limits $1,367 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 can drive over CDP, which Codespaces does not offer; boat also gives agents Chromium and browser control. | 275th of 367, with limits $678 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 | 310th of 346, with limits $922 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 | 280th of 338, with limits $18,637 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 | 267th of 360, with limits $445 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 | GitHub Codespaces | Google Agent Runtime | boat |
|---|---|---|---|
| What it is | A cloud dev environment per GitHub repository, opened in VS Code, the browser or the CLI | Managed agent hosting plus code, shell and browser sandboxes inside Google Cloud | A sandbox API: full VMs you drive from code, with coding agents built in |
| Isolation | A Docker container on its own newly built VM, with its own virtual network | Secure container sandboxing inside your Google Cloud project | Every sandbox is a full VM with its own kernel |
| Root, Docker and nested virtualization | Docker and sudo inside the dev container; /dev/kvm 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 |
| How long it runs | Stops after 30 idle minutes by default and after 12 hours at most, even while in use | Deleted when its TTL ends: up to 7 days for a custom container, 14 days for Code Execution | Runs until you stop it; no session cap on paid plans |
| Shell access | SSH and a terminal in VS Code or the browser | execute_bash() API calls; each command runs in a new shell; no SSH | SSH, plus an API for commands |
| Desktop and computer use | VS Code, JupyterLab and a terminal; no graphical desktop | A browser in a container with a VNC live view, a click, type and screenshot API, and CDP | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Files after a stop | Files kept and storage billed; stopped codespaces deleted after 30 days by default | Pause keeps the file system at a lower rate Google does not publish; deleted at TTL end | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork and snapshots | No copy or snapshot endpoint; each codespace starts from a repo, branch or prebuild | Snapshots keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox into copies with its files; named snapshots as templates (no memory snapshots) |
| Reaching the sandbox | A URL per forwarded port, private, organization or public; no public 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 IPv6 or IPv4 |
| Outbound internet | Open internet; GitHub says there is no way to restrict it | Off unless the template turns it on; can route through your VPC with Cloud NAT, a static IP or a firewall | Open internet on every plan; no provider-side allowlist |
| Coding agents | GitHub Copilot as a VS Code extension; other agents you install yourself | Managed Agents API (Preview) runs Google's Antigravity harness | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets copied into the codespace as environment variables | You provision and scope the credentials the agent uses | AI credentials proxy for model providers and any HTTPS API you register |
| Hosting your agent code | Not offered; you run your agent in a terminal | Deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns not billed | You run your own agent loop inside a sandbox |
| Regions | US East, US West, Europe West and Southeast Asia | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | GitHub Codespaces | Google Agent Runtime | boat |
|---|---|---|---|
| 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 | No | No | Yes |
| Browser | No | 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 | 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 | No | Yes | Yes |
| Idle auto-stop | Yes | 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 | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | 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 | Yes | 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 measurement for GitHub Codespaces or Google Agent Runtime: neither was in the public benchmark run we use. boat 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. GitHub Codespaces 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 | GitHub Codespaces, a month | Google Agent Runtime, a month | boat, 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 | $51 · Personal account: GitHub Free | $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 | $270 · Personal account: GitHub Free · 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 | $3,019 · Personal account: GitHub Free | $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 | $850 · Personal account: GitHub Free · 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,889 · Personal account: GitHub Free · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, plus $0.07 per GB-month of storage while it exists, stopped too. There is no 4-core machine with 8 GB, so a 4 vCPU / 8 GB job is priced on the 4-core 16 GB machine; personal accounts get a free monthly quota and organizations do not.
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: 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
Codespaces does not fit the agent that never stops, because every codespace stops after 12 hours, and GitHub does not publish how many can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed. Google does not fit the 50-agent fleet because its sandboxes have no Docker inside, and every Google row leaves disk and egress unpriced because those rates are not published. On boat 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 | GitHub Codespaces | Google Agent Runtime | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| 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 GitHub Codespaces when
your developers want a ready VS Code environment with Docker for a GitHub repository, opened from a branch or pull request, for sessions under 12 hours.
- Built into GitHub. Useful if your team lives on GitHub: open a ready dev container from any repo, branch or pull request.
- Docker and sudo in the box. Useful if your work needs Docker builds or apt installs: a codespace gives you both, which Google's sandboxes do not.
- Free hours for personal accounts. Useful for occasional personal work: a GitHub Free account includes 120 core-hours and 15 GB-month of storage each month.
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.
- Longer lives and memory snapshots. Useful if a sandbox must live for days or branch with its memory: TTLs reach 7 days and snapshots keep memory.
- Inside your Google Cloud network. Useful if agents must stay in a Google Cloud perimeter, with egress off by default and routed through your firewall.
Where boat fits
If what you are really running is coding agents, both fall short in a different place: Codespaces gives you Docker but stops at 12 hours, and Google lives longer but takes away root and Docker. boat gives each agent a full VM with root, Docker and /dev/kvm that runs until you stop it, with a desktop, public ports and coding agents built in.
A full VM that keeps running
A codespace stops at 12 hours even while in use, so an agent needs a restart script and loses its processes. Google sandboxes are deleted at the end of their TTL. A boat VM has no session cap on paid plans and saves its disk every minute.
Root, Docker and /dev/kvm together
Google sandboxes run as appuser with no sudo or Docker, so you bake every tool into an image. Codespaces has Docker but no documented /dev/kvm, so emulators and microVMs are out. boat has root, systemd, Docker and /dev/kvm on every machine.
Agents you drive from outside, with keys kept out
On Codespaces you start and watch each agent over SSH with keys in environment variables, and Google only runs its own Antigravity harness. boat preinstalls Claude Code, Codex and OpenCode with a prompt, steer and events API and a credentials proxy.
Use boat when your agents need a real computer that keeps running: root, Docker, /dev/kvm, SSH, a desktop and public URLs on a full VM, with Claude Code, Codex and other coding agents built in. Compare it one to one: boat vs GitHub Codespaces and boat vs Google Agent Runtime.
Questions people ask
Is GitHub Codespaces cheaper than Google Agent Runtime?
In most scenarios we priced, yes: one coding agent on workdays is $51 a month on Codespaces against $73 on Google, and 50 agents in parallel are $3,019 against $3,626, though Google cannot run that fleet without Docker. boat comes to $20 and $317 for the same two scenarios.
Which is faster, Codespaces or Google Agent Runtime?
Neither has a comparable measurement in the public benchmark run we use, so we cannot say. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29.
Can GitHub Codespaces or Google Agent Runtime run Docker?
Codespaces can: Docker works inside the dev container and you have sudo. Google's sandboxes run as the unprivileged user appuser with no sudo, and custom images must not need root, so Docker is not available. Every boat machine has root, Docker and /dev/kvm.
Can I run an AI agent 24/7 on either?
Not without restarts. A codespace stops after 12 hours at most, even while in use, and a Google sandbox is deleted when its TTL ends, 7 days at most for a custom container. A boat sandbox runs until you stop it, with 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 boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs GitHub Codespaces
- boat vs Google Agent Runtime
- E2B vs GitHub Codespaces
- Daytona vs GitHub Codespaces
- Modal vs GitHub Codespaces
- Vercel Sandbox vs GitHub Codespaces
- Cloudflare Sandbox vs GitHub Codespaces
- Blaxel vs GitHub Codespaces
- Runloop vs GitHub Codespaces
- Tensorlake vs GitHub Codespaces
- Morph Cloud vs GitHub Codespaces
- CodeSandbox SDK vs GitHub Codespaces