Namespace vs Together Code Sandbox
Namespace is a build and dev platform: CI runners, caches and Devboxes on Linux, macOS and Windows that stop after 4 to 24 hours. Together Code Sandbox starts VMs from Docker-image snapshots on Together's AI cloud, can save their memory when they end, and must be enabled for your organization by Together.
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, and they also host sessions for Claude Managed Agents, Cursor Cloud Agents and Devin. 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 from a container image you choose and include Docker; the docs do not say whether each one has its own kernel
- Funding
- Announced a $42M Series B
- Compliance
- Trust center lists SOC 2 Type II
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.
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. “80th cheapest of 377” means 79 of the other 376 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 | Together Code Sandbox: price rank | boat: 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: Namespace Devboxes have Docker but stop after at most 24 hours, Together's new SDK does not document Docker inside, and boat has Docker, root and /dev/kvm on every machine. | 39th of 367, with limits $3,495 a month | 65th of 367, with limits $528 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that never stops is a compromise on both: a Namespace Devbox is shut down after at most 24 hours, and Together's priced Code Interpreter sessions end after 60 minutes; boat has no session cap on paid plans. | 303rd of 366, with limits $6,645 a month | 152nd of 366, with limits $1,095 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 Namespace costs $250 a month here against $2,190 on Together Code Sandbox and $2,000 on boat, because it bills per minute with no plan fee while Together's Code Interpreter bills per 60-minute session. | 247th of 345, with limits $250 a month | 326th of 345, with limits $2,190 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 | 284th of 361, with limits $2,068 a month | 234th of 361, with limits $900 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 Together can save a sandbox with its memory and start many copies from it, which suits rollouts that branch from one warm state, but the VM product needs Together to enable it. | 356th of 360, with limits $9,012 a month | 315th of 360, with limits $21,900 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 | 282nd of 364, with limits $1,043 a month | 258th of 364, with limits $450 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 runners are Namespace's main product, with caches for Docker, Bazel and more, so it fits fully; Together is a compromise, and boat runs CI jobs on full VMs with Docker and /dev/kvm. | 80th cheapest of 377 $765 a month | 251st of 377, with limits $180 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Namespace Devbox stops when idle and starts again when you connect, but is shut down after at most 24 hours; Together's Code Interpreter keeps nothing after a session, and a boat machine stays up as long as you want. | 126th of 368, with limits $168 a month | 210th of 368, with limits $22 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 Namespace's screenshot and click API works on macOS Devboxes only and Together Code Sandbox has no desktop, while boat streams a 60fps Linux desktop with Chromium. | 67th of 369, with limits $982 a month | 184th of 369, with limits $600 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 | 285th of 367, with limits $789 a month | 301st of 367, with limits $900 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 | 259th of 346, with limits $332 a month | 219th of 346, with limits $180 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 | 226th of 338, with limits $9,012 a month | 124th of 338, with limits $3,600 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 | 242nd of 360, with limits $339 a month | 167th of 360, with limits $150 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 Only Namespace fits: it runs macOS Devboxes and instances on Apple Silicon, and neither Together Code Sandbox nor boat has macOS. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | Together Code Sandbox | boat |
|---|---|---|---|
| Isolation | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | A VM per sandbox on Together's infrastructure | Every sandbox is a full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| Getting started | Sign up for a 30-day Developer trial with no card | The VM SDK and CLI must be enabled for your organization by Together; Code Interpreter is self-serve from prepaid credits | Sign up and start a sandbox from the API, CLI or dashboard |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.79 runs/s | Not measured | 26.69 runs/s |
| Machine size | 4 vCPU / 8 GB and bigger Devbox sizes; vCPU is a ceiling it can boost to | 0.1 to 16 cores, 1 to 8 GB of memory per core; disk size fixed | 2 to 16 vCPU with 2 GB per vCPU, up to 16 vCPU / 32 GB on the $100 plan and above |
| Docker and root | Docker and root in Linux Devboxes | Commands run as user 1000 by default, root on request; Docker inside not documented | Docker, root and systemd on every machine |
| Nested virtualization | /dev/kvm on Linux compute instances, not on macOS or Windows | Not documented | /dev/kvm on every machine, for Android emulators and VMs |
| How long a session can run | Devboxes stop after 4, 5 or 24 hours by plan, 24 at most, even while you work | VM sandboxes run until you end them or their time to live runs out; Code Interpreter sessions last 60 minutes | No session cap on paid plans |
| Saving state | A stopped Devbox keeps its storage at $0.20 per GB-month used; compute instances can suspend with RAM kept | End a sandbox with a snapshot of its disk, or disk and memory; new sandboxes resume with processes running | Disk saved every minute and on stop; a stopped sandbox costs nothing; resume boots the machine again |
| Fork | No fork | No live fork: the parent ends, then you start many sandboxes from its snapshot | Fork a running sandbox; the original keeps running |
| Idle stop and wake | Devboxes stop after an idle timeout (15 minutes to 8 hours) and start again when you connect | Time to live counts from creation; no idle detection and no wake on request | Runs until you stop it or its time to live ends; started again by API |
| Reaching the sandbox | HTTPS URLs that need a Namespace login, TCP through a running CLI port-forward; no public IP | All ports public; preview URLs coming soon; an experimental inbound allowlist by IP or token | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 |
| Desktop and computer use | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | None; headless command and file access only | 60fps Linux desktop with Chromium, computer use and browser control |
| Coding agents | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server for your own agent | Run your own agent through execs; a Harbor guide for agent evals | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only | Linux only; Wine for Windows apps |
Every feature Battleships tracks (43)
| Feature | Namespace | Together Code Sandbox | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | 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 | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | Yes | No | 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 | Yes | 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 | No | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public run of 2026-09-29 at 4 vCPU / 8 GB, boat did 26.69 Node.js build-and-test runs per second and Namespace did 21.79, so the same build takes about a fifth longer on Namespace. Together Code Sandbox was not part of that run, so there is no comparable number for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). Together Code Sandbox has 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 | Namespace, a month | Together Code Sandbox, 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 | $50 · Devbox (pay as you go) | $5 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $176 · Devbox (pay as you go) · with limits | $22 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $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,198 · Devbox (pay as you go) | $264 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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,214 · Devbox (pay as you go) | $900 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $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,237 · Devbox (pay as you go) | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
Namespace: Devboxes are billed in Devbox Minutes at $0.004 each, pay as you go on every plan: a 4 vCPU / 8 GB Devbox uses one a minute. The minutes in the Team and Business plans cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
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, $5 minimum.
Together Code Sandbox: 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
On Namespace the limit that bites is time: a Devbox is shut down after 4, 5 or 24 hours by plan, so an agent that never stops restarts at least once a day, and Namespace publishes no Devbox concurrency limit or egress price. The Together column is Code Interpreter, which 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. On boat the limit is starts, so 1,000 short jobs at once get queued and need more starts per day than even the $2,000 plan allows.
| Scenario | Namespace | Together Code Sandbox | boat |
|---|---|---|---|
| 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 Namespace when
you need macOS or Windows machines, faster GitHub Actions runners with build caches, or Devboxes for people that stop when idle and start on connect.
- macOS and Windows. Useful if your agents 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 and Turborepo caching.
- Egress rules and idle stop. Useful if agents may reach only chosen domains, or boxes should stop when nobody uses them and start on connect.
Use Together Code Sandbox when
you already run models on Together and want light sandboxes, from a tenth of a core, that you can save with their memory and branch from, or a simple Python runner billed per session.
- Memory snapshots to branch from. Useful for rollouts and test variants: save a sandbox with its memory and start many copies with processes still running.
- 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.
- Very small machines and a Python runner. Good for many light jobs: sandboxes start at a tenth of a core, and a Python interpreter API bills per session.
Where boat fits
Look at boat if what you are really running is agents that work for hours or days on Linux. Each one gets a full VM with its own kernel, Docker, systemd and /dev/kvm, a faster CPU than Namespace in the same test, a 60fps desktop, and coding agents you drive from outside, and you can sign up today.
No clock on the session
A Namespace Devbox is shut down after 4, 5 or 24 hours even mid-task, and Together's self-serve Code Interpreter ends after 60 minutes. Your code must restart and resume the agent each time; on boat's paid plans it runs as long as the work does.
A Linux desktop for computer use
Namespace's screenshot and click API works on macOS Devboxes only, and Together has no desktop at all. You install a desktop, VNC and a browser yourself, or pay for macOS minutes; boat streams a 60fps desktop with Chromium in every sandbox.
Servers other people can reach
Namespace URLs need a Namespace login and TCP needs a running CLI port-forward, while every Together port is public and preview URLs are not out yet. boat gives token-protected HTTPS on up to 50 ports, raw TCP and a dedicated IP.
Use boat when your agents work on Linux for hours or days: a full, faster VM with no session cap, Docker and /dev/kvm, a 60fps desktop, private hosting, and coding agents you drive from outside. Compare it one to one: boat vs Namespace and boat vs Together Code Sandbox.
Questions people ask
Is Namespace cheaper than Together Code Sandbox?
Together's only self-serve price is Code Interpreter, which fits none of our scenarios, so it is not a like-for-like match. For sandboxes for your users it comes to $900 against $1,214 on Namespace and $200 on boat; for 1,000 short jobs at once it is $6,000 against $3,237 on Namespace and $2,000 on boat.
Which is faster, Namespace or Together Code Sandbox?
Only Namespace has a comparable measurement: 21.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run. Together was not tested. boat did 26.69 in the same run.
Can Namespace and Together Code Sandbox run Docker?
Namespace Linux Devboxes include Docker, and its Linux compute instances expose /dev/kvm. Together builds sandboxes from Docker images, but its new SDK documents neither Docker inside a sandbox nor nested virtualization. boat has Docker, systemd, root and /dev/kvm on every machine.
How long can a session run on each?
A Namespace Devbox stops after 4 hours on Developer, 5 on Team and 24 on Business, even while you work. Together's VM sandboxes run until you end them or a time to live runs out, and Code Interpreter sessions last 60 minutes. boat has no session cap on paid plans.
Can I start using Together Code Sandbox today?
Only Code Interpreter is self-serve, from prepaid credits with a $5 minimum. The VM SDK and CLI must be enabled for your organization by Together. Namespace offers a 30-day Developer trial with no card, and boat starts on sign-up.
Do Namespace or Together Code Sandbox run macOS?
Namespace does, on Apple M4 Pro and M5 Max machines, and it also runs Windows on Team plans and up. Together Code Sandbox and boat run Linux only.
Try boat
Install the CLI, then run boat new.
7-day free trial