Namespace vs Google Agent Runtime

Namespace is a build and dev platform: CI runners, caches and Devboxes with Docker that stop after 3 to 24 hours by plan. Google Agent Runtime, once called Vertex AI Agent Engine, hosts your agent code on Google Cloud. Its Agent Sandbox runs code as an unprivileged user in a gVisor-isolated container, kept for up to 7 days.

The companies and products

Namespace

Namespace is a dev platform for fast builds, tests and coding environments: CI runners, build caches and Devboxes, on its own hardware.

Most of Namespace is CI: a faster drop-in for GitHub Actions runners, with Docker, Bazel, Turborepo and Nix caching. Its Devboxes are remote Linux and macOS machines with persistent storage, made for people and AI coding agents. You run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions, and Namespace also hosts sessions for Claude Managed Agents, Cursor Cloud Agents, Devin and Amp. It is a different kind of product from boat, so this page compares the part where they overlap: a machine an agent works on.

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. Each sandbox runs in a gVisor-isolated container in a Google-managed tenant project. Teams on GKE can also run the open-source GKE Agent Sandbox in their own cluster, with gVisor or Kata Containers, and manage it themselves.

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. “87th cheapest of 374” means 86 of the other 373 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 workloadNamespace: price rankGoogle Agent Runtime: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
Both are a compromise for a software factory. Namespace Devboxes have Docker but stop at 3 to 24 hours by plan, and cap at 50 per workspace. Google's sandboxes run without root, and Google documents no Docker inside them. boat is a full match here.
74th of 365, with limits
$3,745 a month
310th of 365, with limits
$5,801 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
Google keeps a sandbox for up to 7 days and carries state into a new one with a snapshot (Preview), so it fits an always-on assistant. A Namespace Devbox stops after 24 hours at most, so it is a compromise. On a boat paid plan you turn auto-stop off (default 1 hour).
316th of 361, with limits
$6,645 a month
34th cheapest of 361
$7,519 a month
6th cheapest of 361
$657 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
All three are a compromise for big bursts here. Google has a ready Code Execution sandbox, Namespace caps Devboxes at 50 per workspace, and boat refuses starts above 3 times its per-minute limit.
244th of 336, with limits
$250 a month
251st of 336, with limits
$275 a month
189th of 336, 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
279th of 349, with limits
$2,068 a month
275th of 349, with limits
$1,916 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
345th of 349, with limits
$9,012 a month
132nd of 349, with limits
$8,240 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
282nd of 359, with limits
$1,093 a month
90th cheapest of 359
$2,060 a month
10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
Namespace fits: CI runners with build caches are its main product. Google fits too, but CI jobs that build containers need Docker, which you run outside its sandboxes. boat also fits, with Docker and /dev/kvm on every sandbox.
87th cheapest of 374
$765 a month
104th cheapest of 374
$989 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
Both are a compromise for a box that stays up. Namespace Devboxes have SSH and stop when idle, but end after 24 hours at most. Google documents no SSH into a sandbox. A boat sandbox stays up once auto-stop is off, and bills at full rate while it runs.
201st of 371, with limits
$250 a month
317th of 371, with limits
$241 a month
19th cheapest of 371
$26 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
Both are a compromise for a Linux computer-use agent. Namespace's click API and VNC desktop work on macOS Devboxes; on a Linux Devbox you install a desktop in your image. Google gives you a browser with a VNC live view and a click API, not a full desktop. boat streams a built-in Linux desktop at 60 fps.
108th of 367, with limits
$1,032 a month
85th of 367, with limits
$1,648 a month
7th cheapest of 367
$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. On Namespace you install Chrome or Playwright in your Devbox image. boat ships Chrome with browser control on its built-in desktop.
191st of 356, with limits
$789 a month
132nd of 356, with limits
$824 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
191st of 343, with limits
$332 a month
56th cheapest of 343
$515 a month
6th cheapest of 343
$90 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
225th of 327, with limits
$9,012 a month
212th of 327, with limits
$8,240 a month
73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
112th of 351, with limits
$339 a month
281st of 351, with limits
$412 a month
3rd cheapest of 351
$200 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Only Namespace fits: it runs macOS on Apple Silicon. Google's sandboxes and boat run Linux only.
6th cheapest of 35
$1,255 a month
Not ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureNamespaceGoogle Agent Runtimeboat
Kind of productCI runners, build caches and Devboxes on Namespace's own hardwareManaged agent hosting plus code, shell and browser sandboxes on Google CloudAgent sandboxes: a full VM per agent, with coding agents installed
IsolationLinux Devboxes run a container image; the docs do not say if each has its own kernel (a third-party benchmark reports Firecracker)gVisor-isolated container in a Google-managed tenant projectFull VM with its own kernel on a host dedicated to boat; vCPUs are shared
CPU benchmark (Node.js V8 Web Tooling, 4 vCPU / 8 GB, StarSling run of 3 October 2026)24.90 runs/s, rank 2 of 15 (shared)Not in the public benchmarks we use28.06 runs/s, rank 2 of 15 (shared), on a Ryzen 9 9950X host
Root, Docker and nested virtualizationDocker in Linux Devboxes; /dev/kvm on Linux compute instancesRuns as appuser with no sudo; images must not need root; Docker and /dev/kvm inside are not documented; you build images outside and push them to Artifact RegistryRoot, systemd, Docker and /dev/kvm on every sandbox
How long a session can runDevboxes stop at 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while in use; support can raise it to 24 at mostTTL of up to 7 days for a custom container, 14 days for Code Execution; a snapshot (Preview) carries the state into a new sandboxNo cap once auto-stop is off on a paid plan; auto-stop defaults to 1 hour
Shell accessSSH into Devboxesexecute_bash() API calls; each command runs in a new shell; SSH is not documentedSSH, plus an API for commands
Desktop and computer usemacOS Devboxes: screenshot and click API and a VNC desktop. Linux Devboxes: install a desktop and VNC in your image. Compute instances: VNC and RDPA browser in a container with a VNC live view, a click, type and screenshot API, and CDP; a full desktop is not documented, you can build one into a custom image without rootBuilt-in Linux desktop and Chrome at 1920x1080, 60 fps, with computer tools for agents
Files after a stopA stopped Devbox keeps its storage until you delete it, billed at $0.20 per GB-month usedPause keeps the file system at a lower, unpublished rate; the sandbox is deleted when its TTL ends, and a snapshot (Preview) saves files and memoryDisk saved every minute and on stop; no machine or disk charge while stopped; disk kept at least 14 days (save a snapshot to keep it longer)
Snapshots and branchingNo fork documented; compute instances suspend and resume with RAM and disks keptSnapshots (Preview) keep memory and files; start many sandboxes from one snapshotFork a running sandbox from its last 1-minute snapshot; resume is a reboot from disk
Reaching the sandboxHTTPS URLs that need a Namespace login; TCP through a running CLI port-forward; no public IPThrough Google's API or a private endpoint in your VPC; a public URL is not documentedUp to 50 HTTPS URLs, token-gated by default; SSH over IPv4 through a shared host and port; raw ports over IPv6 on some sandboxes; no dedicated IPv4
Outbound internetEgress policies per Devbox blueprint, runner or instance: block, advisory or allow by domainOff unless the template turns it on; can route through your VPC with Cloud NAT, a static IP and your firewallOpen internet on every plan; no provider-side allowlist; egress not billed
Coding agentsYou run Claude Code, Codex, OpenCode, Amp, Copilot or Cursor in persistent Devbox sessions; hosts Claude Managed Agents, Cursor, Devin and Amp sessions; no API to prompt or steer an agent from outsideAgent Runtime hosts ADK and LangGraph agents; Managed Agents API (Preview) runs Google's Antigravity harness; other harnesses you install in a custom imageSeven harnesses installed, including Claude Code, Codex and OpenCode, with an API to prompt, steer and stream events
Operating systemsLinux, macOS on Apple Silicon, and Windows on Team plans and upLinux onlyLinux only; Windows programs run through Wine
RegionsSeveral regions; keeping a workload inside one region needs Enterprise23 locations in the US, Europe, the Middle East, Asia, Canada, Australia and BrazilGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureNamespaceGoogle Agent Runtimeboat
Full VM (own kernel)YesNo documented wayYes
Docker insideYesNo documented wayYes
Nested virtualizationYesNo documented wayYes
RootYesNo documented wayYes
SystemdNot publishedNot publishedYes
Desktop GUIYesNot publishedYes
BrowserWith your own setupYesYes
Computer-use APIYesYesYes
SSHYesNo documented wayYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
Fork/cloneNo documented wayYesYes
Live fork (no pause)No documented wayYesYes
Memory forkNo documented wayYesNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesNo documented wayNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesNo documented wayYes
Raw TCP inboundYesNot publishedYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesNo documented wayYes
Secret proxy for any APIYesNo documented wayYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayYesYes
MCP serverYesNo documented wayNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsYesNo documented wayNo documented way
Arm64YesYesNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsYesNot publishedYes
Usage per sandbox (API)No documented wayYesYes
Audit logsYesNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAANo documented wayYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Namespace24.90 runs/s
Google Agent RuntimeNot measured
boat28.06 runs/s

In StarSling's run of 3 October 2026 (run 37073680030), the Node.js V8 Web Tooling benchmark at 4 vCPU / 8 GB did 28.06 runs/s on boat and 24.90 on Namespace. Both share rank 2 of 15, so the run cannot separate them. Google Agent Runtime and its sandboxes are not in the public benchmarks we use, so we cannot say which is faster. StarSling does not name the Namespace product it tested. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Providers ran on different hardware in different regions.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Google Agent Runtime is not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

ScenarioNamespace, a monthGoogle Agent Runtime, a monthboat, 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
$300 · Devbox on Business$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
$426 · Devbox on Business · 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
$2,448 · Devbox on Business$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,264 · Devbox Plus · 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
$3,287 · Devbox Plus · with limits$2,060 · Pay as you go$8,800 · $2000/mo · with limits

Namespace: Devboxes are billed in Devbox Minutes at $0.004 each: a 4 vCPU / 8 GB (size S) Devbox uses one a minute. Pay as you go, or Devbox Plus at $250 a month for 50,000 minutes and 400 GB-month of storage. Team ($100) and Business ($250) plan minutes do not cover Devboxes, but you need those plans for longer sessions and more Devboxes. Storage costs $0.20 per GB-month used.

Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, rounded to the second. The pricing page lists 50 vCPU-hours and 100 GiB-hours free each month but does not say they cover sandboxes. Runtime skips idle time between turns, but sandboxes are billed while they exist. Pause, disk, snapshot and egress rates are not published.

Google Agent Runtime: Plans cost $20, $100, $500 or $2,000 a month. The whole plan price comes back as VM time for that month; unused time does not carry over. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs. A stopped sandbox has no compute charge and keeps its disk for at least 14 days; saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07 each. A card is required, also for the 7-day free trial.

Limits in those scenarios

On Namespace the limit is time and count: a Devbox stops at 3, 5 or 24 hours by plan, and a workspace holds 50 Devboxes at most, stopped ones included. So the agent that never stops, sandboxes for your users and 1,000 short jobs at once do not fit. On Google the limit is what runs inside: the 50-agent fleet does not fit because Google documents no Docker in its sandboxes, and disk and egress rates are not published. Namespace does not publish an egress price either. On boat the 1,000-job burst does not fit: the $2,000 plan includes 90 starts a minute and 2,400 a day, and starts above 270 a minute fail. boat also needs auto-stop off for always-on work (default 1 hour), and a resume does not keep memory.

ScenarioNamespaceGoogle Agent Runtimeboat
One coding agent, workdays
  • egress price not published
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
One agent that never stops
  • Devbox on Business: sessions capped at 24 h
  • egress price not published
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
50 agents in parallel
  • egress price not published
  • missing Docker inside
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
Sandboxes for your users
  • Devbox Plus: max 50 concurrent
  • egress price not published
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
1,000 short jobs at once
  • Devbox Plus: max 50 concurrent
  • egress price not published
  • disk beyond 0 GiB: price unknown
  • egress price not published
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

Which one should you use?

Use Namespace when

you need Docker and SSH on a dev machine, macOS or Windows, or faster GitHub Actions runners with build caches.

  • Docker and SSH on a dev machine. Useful if your agents run docker compose or apt installs: Namespace Devboxes include Docker and SSH, which Google does not document in its sandboxes.
  • macOS and Windows. Useful if you build iOS or Mac apps or test on Windows: Namespace runs macOS on Apple Silicon and Windows machines.
  • CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel, Turborepo and Nix caching.

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 or large bursts in a gVisor 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.
  • Longer sandbox life and memory snapshots. Useful if a sandbox must live for days or branch with its memory: Google keeps it up to 7 days and snapshots memory (Preview).
  • Inside your Google Cloud network. Useful if agents must stay in a Google Cloud perimeter, in one of 23 locations, with egress routed through your own firewall.

Where boat fits

If you run coding agents that work for hours or days, Namespace is a CI and dev platform with a 24-hour cap at most, and Google runs agents in gVisor containers without root. boat gives each agent a full VM with root, Docker, a built-in desktop and public URLs, with no session cap once auto-stop is off.

No clock on the session

A Namespace Devbox stops at 3, 5 or 24 hours by plan, even while it works. A Google sandbox is deleted when its TTL ends, 7 days at most, unless you restore a snapshot into a new one. On a boat paid plan you turn auto-stop off (default 1 hour). A boat resume is a reboot, so memory is not kept.

A full VM with root and Docker

Google's sandboxes run as appuser with no sudo, and Google documents no Docker inside, so you run Docker builds on another service. Namespace has Docker in Devboxes. boat gives each sandbox its own kernel, root, systemd, Docker and /dev/kvm.

Agents installed, reachable from outside

On Namespace you start each agent in a Devbox session, and on Google you install other harnesses in a custom image. Neither documents a public URL. boat installs seven harnesses with a prompt API and serves HTTPS on up to 50 ports.

Use boat when your agents need a full VM on Linux for hours or days: root, Docker, SSH, a built-in desktop and public HTTPS URLs, with no session cap once auto-stop is off and seven coding agents installed. boat runs in the EU only and caps starts per plan. Compare it one to one: boat vs Namespace and boat vs Google Agent Runtime.

boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Questions people ask

Is Namespace cheaper than Google Agent Runtime?

It depends on the job. One coding agent on workdays costs $73 a month on Google and $300 on Namespace, because an 8-hour Devbox session needs Namespace Business. 50 agents in parallel cost $2,448 on Namespace Business and $3,626 on Google, though Google documents no Docker for that fleet. Sandboxes for your users ($1,030) and 1,000 short jobs at once ($2,060) fit Google but not Namespace's 50-Devbox cap. boat costs $20, $317 and $200 for the first three, and the burst does not fit boat's start limits.

Which is faster, Namespace or Google Agent Runtime?

Google's sandboxes are not in the public benchmarks we use, so we cannot say. In StarSling's run of 3 October 2026, Namespace did 24.90 V8 Web Tooling runs/s at 4 vCPU / 8 GB and boat did 28.06. Both share rank 2 of 15, so the run cannot separate them.

Can Namespace or Google Agent Runtime run Docker?

Namespace can: Linux Devboxes include Docker, and Linux compute instances have /dev/kvm. Google's sandboxes run as the unprivileged user appuser with no sudo, and Google documents no Docker inside; you build images outside and push them to Artifact Registry. boat has root, Docker and /dev/kvm on every sandbox.

How long can a session run on each?

A Namespace Devbox stops at 3, 5 or 24 hours by plan, even while you work in it. A Google sandbox lives until its TTL ends, up to 7 days for a custom container and 14 for Code Execution. On a boat paid plan there is no cap once you turn auto-stop off; it defaults to 1 hour.

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.

Which one runs macOS?

Only Namespace, which runs macOS Devboxes and instances on Apple M4 Pro and M5 Max chips. Google's sandboxes and boat run Linux only.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons