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.
- Products
- GitHub Actions runners, Docker, Bazel, Turborepo and Nix caching, Devboxes, and a compute API
- Hardware
- Its own hardware in its own racks: AMD EPYC for Linux and Windows, Apple M4 Pro or M5 Max for macOS
- Linux Devboxes
- Run a container image you choose and include Docker; the docs do not say if each one has its own kernel
- Devbox time limit
- 3 hours on Developer and Devbox Plus, 5 on Team, 24 on Business, even while you work; support can raise it to 24 hours at most
- Devbox count limit
- Per user / per workspace: 1/3 on Developer, 3/30 on Team, 5/50 on Business and Devbox Plus; stopped Devboxes count
- Free trial
- 30-day Developer trial with no card
- Compliance
- Trust center lists SOC 2 Type II
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 workload | Namespace: 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 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 requirement | Not ranked: misses a requirement | Not 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 requirement | Not ranked: misses a requirement |
Key features
| Feature | Namespace | Google Agent Runtime | boat |
|---|---|---|---|
| Kind of product | CI runners, build caches and Devboxes on Namespace's own hardware | Managed agent hosting plus code, shell and browser sandboxes on Google Cloud | Agent sandboxes: a full VM per agent, with coding agents installed |
| Isolation | Linux 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 project | Full 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 use | 28.06 runs/s, rank 2 of 15 (shared), on a Ryzen 9 9950X host |
| Root, Docker and nested virtualization | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Runs 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 Registry | Root, systemd, Docker and /dev/kvm on every sandbox |
| How long a session can run | Devboxes 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 most | TTL of up to 7 days for a custom container, 14 days for Code Execution; a snapshot (Preview) carries the state into a new sandbox | No cap once auto-stop is off on a paid plan; auto-stop defaults to 1 hour |
| Shell access | SSH into Devboxes | execute_bash() API calls; each command runs in a new shell; SSH is not documented | SSH, plus an API for commands |
| Desktop and computer use | macOS Devboxes: screenshot and click API and a VNC desktop. Linux Devboxes: install a desktop and VNC in your image. Compute instances: VNC and RDP | A 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 root | Built-in Linux desktop and Chrome at 1920x1080, 60 fps, with computer tools for agents |
| Files after a stop | A stopped Devbox keeps its storage until you delete it, billed at $0.20 per GB-month used | Pause keeps the file system at a lower, unpublished rate; the sandbox is deleted when its TTL ends, and a snapshot (Preview) saves files and memory | Disk 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 branching | No fork documented; compute instances suspend and resume with RAM and disks kept | Snapshots (Preview) keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox from its last 1-minute snapshot; resume is a reboot from disk |
| Reaching the sandbox | HTTPS URLs that need a Namespace login; TCP through a running CLI port-forward; no public IP | Through Google's API or a private endpoint in your VPC; a public URL is not documented | Up 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 internet | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain | Off unless the template turns it on; can route through your VPC with Cloud NAT, a static IP and your firewall | Open internet on every plan; no provider-side allowlist; egress not billed |
| Coding agents | You 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 outside | Agent Runtime hosts ADK and LangGraph agents; Managed Agents API (Preview) runs Google's Antigravity harness; other harnesses you install in a custom image | Seven harnesses installed, including Claude Code, Codex and OpenCode, with an API to prompt, steer and stream events |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only | Linux only; Windows programs run through Wine |
| Regions | Several regions; keeping a workload inside one region needs Enterprise | 23 locations in the US, Europe, the Middle East, Asia, Canada, Australia and Brazil | Germany, Finland and France; you cannot pick a region; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Namespace | Google Agent Runtime | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No documented way | Yes |
| Docker inside | Yes | No documented way | Yes |
| Nested virtualization | Yes | No documented way | Yes |
| Root | Yes | No documented way | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | Not published | Yes |
| Browser | With your own setup | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | No documented way | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No documented way | Yes | Yes |
| Live fork (no pause) | No documented way | Yes | Yes |
| Memory fork | No documented way | Yes | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No documented way | No documented way |
| Wake on request | Yes | No documented way | No documented way |
| HTTPS preview URLs | Yes | No documented way | Yes |
| Raw TCP inbound | Yes | Not published | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | No documented way | Yes |
| Secret proxy for any API | Yes | No documented way | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | Yes | Yes |
| MCP server | Yes | No documented way | No documented way |
| GPU | No documented way | No documented way | No documented way |
| Windows | Yes | No documented way | No documented way |
| Arm64 | Yes | Yes | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | No documented way | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No documented way | Yes | Yes |
| Audit logs | Yes | Not published | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | No documented way | Yes | No documented way |
| EU data residency | Yes | Yes | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
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.
| Scenario | Namespace, 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 | $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.
| Scenario | Namespace | Google Agent Runtime | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None for this scenario |
| One agent that never stops |
|
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 1,000 short jobs at once |
|
|
|
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