Together Code Sandbox vs Google Agent Runtime
Together Code Sandbox starts VMs from Docker-image snapshots on Together's AI cloud, but the VMs must be enabled for your organization. Google Agent Runtime hosts your agent code on Google Cloud and gives it sandboxes that run as an unprivileged user in a locked container.
The companies and products
Together Code Sandbox
Together AI is a cloud for running and training AI models, and Code Sandbox is its product for running code in isolated VMs.
You build a snapshot from a Docker image or Dockerfile on Together's builder, then start sandboxes from it and run commands and file operations through the together-sandbox SDK or CLI. When a sandbox ends you can save its disk, and its memory too, as a new snapshot to start more sandboxes from. It is aimed at model-generated code, agent tool calls and reinforcement learning rollouts, and it must be enabled for your organization by Together. Together also sells Code Interpreter, a separate API that runs Python code in short sessions.
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. “65th cheapest of 367” means 64 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 | Together Code Sandbox: 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 A software factory needs Docker and root; Together's SDK runs commands as a normal user and does not document Docker inside, Google's sandboxes have no sudo or Docker, and bochka has root, Docker and /dev/kvm on every machine. | 65th of 367, with limits $528 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's sandboxes are deleted when their TTL ends, 7 days at most for a custom container, and Together has no idle detection or wake on request, while a bochka VM has no session cap on paid plans. | 152nd of 366, with limits $1,095 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 Short code runs are where both fit best: Together's Code Interpreter runs Python in sessions billed per 60 minutes, and Google's Code Execution sandbox is a ready Python interpreter with no network. | 326th of 345, with limits $2,190 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 Neither gives your users a private URL today: Together makes every port public with preview URLs still coming soon, and Google has no public URL, while bochka serves token-protected HTTPS on up to 50 ports. | 234th of 361, with limits $900 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 Both can save a sandbox with its memory and start many copies from it, which suits rollouts that branch from one warm state; Together's VM product needs Together to enable it first. | 315th of 360, with limits $21,900 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 | 258th of 364, with limits $450 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 jobs that build containers need Docker, which neither Together's SDK nor Google's unprivileged sandboxes document; bochka runs Docker and systemd on every VM. | 251st of 377, with limits $180 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 | 210th of 368, with limits $22 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 you a browser in a container with a VNC view and a click and type API, Together has no desktop or browser, and bochka streams a full 60fps desktop with Chromium. | 184th of 369, with limits $600 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 with Playwright, while on Together you install a headless browser in your own image; bochka ships Chromium on a desktop in every sandbox. | 301st of 367, with limits $900 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 | 219th of 346, with limits $180 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 | 124th of 338, with limits $3,600 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 | 167th of 360, with limits $150 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 | Together Code Sandbox | Google Agent Runtime | bochka |
|---|---|---|---|
| Isolation | A VM per sandbox on Together's infrastructure | Secure container sandboxing inside your Google Cloud project | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Getting started | The VM SDK and CLI must be enabled for your organization by Together; only Code Interpreter is self-serve, from prepaid credits | Pay as you go in your own Google Cloud project | Sign up and start a sandbox from the API, CLI or dashboard |
| Root, Docker and nested virtualization | Commands run as user 1000 by default, root on request; Docker inside and 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 |
| Shell access | Commands, interactive shells and files through the SDK and CLI; no SSH | execute_bash() API calls; each command runs in a new shell; no SSH | SSH, plus exec and files over the API |
| Machine size | 0.1 to 16 cores, 1 to 8 GB of memory per core; disk size fixed | Runtime: 1, 2, 4, 6 or 8 vCPU and up to 32 GiB; sandbox maximum not published | Up to 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB from the $100 plan |
| Saving state | End a sandbox with a snapshot of its disk, or disk and memory; a new sandbox resumes with its processes running | Snapshots keep memory and files; pause keeps the file system and costs less | Disk saved every minute and on stop; a stopped sandbox costs nothing; resume boots the machine again |
| Fork | No live fork: the parent stops, then you start many sandboxes from its snapshot | Start many sandboxes from one snapshot (same image and architecture) | Fork a running sandbox; the original keeps running |
| How long a sandbox lives | Runs until you stop it or its TTL ends; Code Interpreter sessions last 60 minutes | TTL of up to 7 days for a custom container and 14 days for Code Execution | No session cap on paid plans |
| Reaching the sandbox | All ports public; preview URLs coming soon; an experimental inbound allowlist by IP or token | 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 by default; raw TCP; dedicated IPv6 or IPv4 |
| Outbound internet | Open internet; no egress allowlist documented | Off unless the template turns it on; can route through your VPC with Cloud NAT, a static IP, Cloud NGFW or Secure Web Proxy | Open internet on every plan; no provider-side allowlist |
| Desktop and browser | None; headless command and file access only | A browser in a container with a VNC live view, a click, type and screenshot API, and CDP for Playwright | Linux desktop streamed at 60fps, Chromium and computer-use tools |
| Coding agents | Run your own agent through execs; a Harbor guide for agent evals | Managed Agents API (Preview) runs Google's Antigravity harness; no other coding harness named | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Hosting your agent code | Not offered; your agent runs elsewhere and calls the sandbox | Agent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billed | You run your own agent loop inside a sandbox |
| Keeping API keys out of the sandbox | No credentials proxy documented | You provision and scope the credentials the agent uses | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
Every feature Battleships tracks (43)
| Feature | Together Code Sandbox | Google Agent Runtime | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Not published | 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 | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | 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 | 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 | Yes | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Together Code Sandbox or for Google's sandboxes. bochka did 26.69 runs per second on StarSling's Node.js build-and-test benchmark at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts; neither Together nor Google was part of that run.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Together Code Sandbox 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 | Together Code Sandbox, 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 | $5 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $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 | $22 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $264 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $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 | $900 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
Together Code Sandbox: Together lists Code Sandbox at $0.0446 per vCPU-hour and $0.0149 per GiB-hour, but the VMs must be enabled for your organization, so the table prices Code Interpreter: $0.03 per 60-minute session from prepaid credits, with a $5 minimum.
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. 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 becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
The Together column is Code Interpreter, and it fits none of the scenarios: sessions last 60 minutes, nothing is kept after a session, it runs only Python and its machine size is not published. Google fits four of the five, but not the 50-agent fleet, because its sandboxes have no Docker inside, and it leaves disk and egress unpriced. On bochka the limit that bites is starts: 1,000 short jobs at once need more starts per hour and per day than the $2,000 plan allows, so they are queued.
| Scenario | Together Code Sandbox | 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 |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Together Code Sandbox when
you already run models on Together and want light VMs, from a tenth of a core, that you can save with their memory and branch from, or a simple Python runner billed per session.
- Very small VMs. Good for many light jobs that still want a VM: sandboxes run from a tenth of a core up to 16 cores.
- Sandboxes next to your models. Handy if you already run inference or fine-tuning on Together: sandboxes and models share one account and API key.
- A Python runner billed per session. For plain Python, Code Interpreter runs code in sessions billed per 60 minutes, with no VM to manage.
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 code runs 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.
- Inside your Google Cloud network. Useful if agents must stay in a Google Cloud perimeter, with egress off by default and routed through your own firewall.
- Self-serve, in 23 locations. You can start sandboxes today in your own project, in regions across the US, Europe, Asia, Canada, Australia and Brazil.
Where bochka fits
Both products keep the agent on a short leash: Together's VMs run as a normal user and need Together to switch them on, and Google's sandboxes are locked containers with no sudo. If your agents install packages, run Docker, start servers people visit or use a desktop, bochka gives each one a full VM you can start today.
Root, Docker and a real kernel
Together runs commands as user 1000 and documents no Docker inside; Google runs as appuser with no sudo. On both you bake every tool into an image first, and Docker builds or emulators have to run somewhere else.
Private URLs for what agents build
On Together every port is public and preview URLs are still coming soon; on Google there is no public URL, so you set up a VPC endpoint, load balancer or tunnel yourself. bochka serves token-protected HTTPS on 50 ports and raw TCP.
Coding agents and keys built in
Neither ships Claude Code or Codex, so you install them in an image and pass keys in where code in the sandbox can read them. bochka preinstalls the agents, drives them from outside and keeps real keys in a credentials proxy.
Use bochka when your agents need a real computer for hours: root, Docker, SSH, a desktop and private URLs on a full VM that keeps its disk, with Claude Code, Codex and their keys already set up. Compare it one to one: bochka vs Together Code Sandbox and bochka vs Google Agent Runtime.
Questions people ask
Is Together Code Sandbox cheaper than Google Agent Runtime?
The only self-serve Together price is Code Interpreter, which fits none of our scenarios. On paper it looks cheaper for short user sessions, $900 against $1,030 a month for sandboxes for your users, but costs more at scale: $6,000 against $2,060 for 1,000 short jobs at once. bochka comes to $200 and $2,000 for those two.
Which is faster, Together Code Sandbox or Google Agent Runtime?
Neither has a comparable CPU measurement, so we cannot say. bochka did 26.69 runs per second on StarSling's Node.js benchmark at 4 vCPU / 8 GB.
Can Together Code Sandbox or Google Agent Runtime run Docker?
Google's sandboxes cannot: commands run as appuser with no sudo, and images must not need root. Together builds sandboxes from Docker images, but its SDK does not document Docker inside a sandbox. bochka runs Docker, systemd and root on every VM, with /dev/kvm for emulators.
Can both save a sandbox with its memory?
Yes. Together saves disk and memory when a sandbox ends, and Google can snapshot memory and files and start many sandboxes from one snapshot. bochka saves the disk every minute and can fork a running sandbox, but resuming boots the machine again.
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 they run?
Together does not publish its regions. Google runs Agent Runtime and sandboxes 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
More comparisons
- bochka vs Together Code Sandbox
- bochka vs Google Agent Runtime
- E2B vs Together Code Sandbox
- Daytona vs Together Code Sandbox
- Modal vs Together Code Sandbox
- Vercel Sandbox vs Together Code Sandbox
- Cloudflare Sandbox vs Together Code Sandbox
- Blaxel vs Together Code Sandbox
- Runloop vs Together Code Sandbox
- Tensorlake vs Together Code Sandbox
- Morph Cloud vs Together Code Sandbox
- CodeSandbox SDK vs Together Code Sandbox