Runloop vs Together Code Sandbox
Runloop is a self-serve platform of devboxes built for coding agents, with Docker, agent gateways, hostname allowlists and a desktop. Together Code Sandbox gives you VMs you can save with their memory and branch from, but Together must turn it on for your organization, and its only self-serve product is a 60-minute Python Code Interpreter.
The companies and products
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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. “20th cheapest of 367” means 19 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 | Runloop: 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 Runloop fits fully with Docker-in-Docker blueprints and root; Together's self-serve option is a Python Code Interpreter, and boat adds /dev/kvm for Android emulators with the disk kept on every plan. | 20th cheapest of 367 $8,152 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 Runloop can suspend an idle devbox and wake it on an HTTP request on Pro, while Together sandboxes have no idle detection or wake on request; boat keeps the machine and its disk for as long as you like. | 32nd cheapest of 366 $10,194 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 Runloop ranks 44th for many short code runs; Together's Code Interpreter is built for this but bills per 60-minute session, and boat's start limits queue very large bursts. | 44th cheapest of 345 $525 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 On Together every port is public and preview URLs are coming soon, Runloop gives each devbox one HTTPS tunnel, and boat ranks 1st with token-protected HTTPS on up to 50 ports. | 26th cheapest of 361 $3,301 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 Runloop ranks 4th for RL rollouts and sells RL fine-tuning on Enterprise; Together can branch many sandboxes from one memory snapshot, but its VM product needs Together to enable it. | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 Runloop and boat both run Docker for builds and tests, and boat's faster CPUs finish them sooner; Together's Code Interpreter runs only Python. | 121st cheapest of 377 $1,554 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 | 113th cheapest of 368 $410 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 Runloop and boat both ship a desktop and a browser an agent can control, with boat streaming at 60fps; Together Code Sandbox has no desktop. | 39th cheapest of 369 $2,306 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 | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 Runloop can lock each devbox to a hostname allowlist, boat gives each one a full kernel with nested virtualization, and Together has only an experimental inbound allowlist. | 10th cheapest of 360 $770 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 | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Runloop | Together Code Sandbox | boat |
|---|---|---|---|
| Getting started | Self-serve: Basic plan is usage only, with a trial credit | VM SDK must be enabled for your organization; Code Interpreter is self-serve on prepaid credits | Sign up and start a sandbox from the API, CLI or dashboard |
| Isolation | Micro-VM on a custom hypervisor, plus a container layer | A VM per sandbox on Together's infrastructure | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Yes, on the Docker-in-Docker blueprints, as root | Not documented; commands run as user 1000 by default, root on request | Docker, systemd and root on every machine |
| Nested virtualization | Not documented | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Images | Blueprints built from Dockerfiles, x86_64 or arm64 | Snapshots built from a Docker image or Dockerfile | Templates from named snapshots of a running sandbox, x86_64 only |
| Saving state | Disk kept through suspend (Pro) or manual disk snapshots; shutdown ends the devbox | End a sandbox with a snapshot of its disk, or disk and memory, and start copies from it | Disk saved every minute and on stop on every plan; a stopped sandbox costs nothing |
| Long runs | Fixed lifetime up to 48 hours, or an idle policy with no documented cap | VM sandboxes run until you end them; Code Interpreter sessions last 60 minutes | No session cap on paid plans; time to live is yours to set |
| Idle sleep and wake | Suspend after idle, wake on an HTTP request (Pro) | No idle detection and no wake on request | No idle timer; runs until you stop it or its time to live ends |
| Reaching the sandbox | One HTTPS tunnel per devbox, open or bearer token; SSH through a TLS proxy | All ports public; preview URLs coming soon; no SSH | SSH, HTTPS on up to 50 ports token-protected by default, raw TCP, dedicated IPv6 or IPv4 |
| Egress rules | Hostname allowlist with wildcards, or block all | No egress allowlist documented | Open internet, no provider-side allowlist |
| Desktop and browser | Desktop and browser an agent can control | None; headless commands and files only | Linux desktop streamed at 60fps, Chromium and computer-use tools |
| Coding agents | Claude Code, Codex, OpenCode, Gemini CLI and more, driven through Axons | 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 |
| Keeping API keys out | Agent gateways for any API with bearer, header or basic auth | No credentials proxy documented | Credentials proxy for any HTTPS API; switch to another account when credits run out |
| Where it runs | Regions not documented; deploy to your own AWS, GCP or Azure (Enterprise) | Regions not published | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Runloop | Together Code Sandbox | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | 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 | Yes | Yes | Yes |
| Live fork (no pause) | Yes | 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 | No | 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 | Yes | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Not published | No | No |
| EU data residency | No | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, boat ran 26.69 runs a second and Runloop 8.29, about 3.2 times apart. There is no comparable measurement for Together Code Sandbox, which was not part of that run. The test measures CPU work only, not start time or network speed.
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 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 | Runloop, 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 | $113 · Basic | $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 | $429 · Basic | $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 | $5,268 · Basic | $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,441 · Basic | $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,184 · Basic | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
Runloop: Runloop bills per second for the CPU and memory you allocate, including while a devbox starts, suspends or resumes, and bills its disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.
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. The tables price Code Interpreter instead, its self-serve product: $0.03 per 60-minute session from prepaid credits.
Together Code Sandbox: Plans start at $20 a month and the whole fee is usage credit, billed per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
The Together column is Code Interpreter, so it fits none of the scenarios: sessions end after 60 minutes, nothing is kept, it runs only Python and the machine size is not published. Runloop fits every scenario, but its fixed lifetime tops out at 48 hours unless an idle policy replaces it, and it publishes no egress price. On boat the limit that bites is starts: 1,000 short jobs at once need more starts than even the $2,000 plan allows, so they are queued.
| Scenario | Runloop | 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 Runloop when
you want self-serve devboxes for coding agents now, launch very large bursts of short jobs, or need hostname allowlists, arm64 or devboxes in your own cloud.
- Ready for coding agents today. For teams that want to start now: Runloop is self-serve, with Docker-in-Docker, a desktop and agents like Claude Code driven through Axons.
- Network rules and your own cloud. Useful if a devbox must only reach listed hostnames, or must run inside your own AWS, GCP or Azure account (Enterprise).
- Sleep when idle, arm64 builds. Handy for idle devboxes and arm64 work: Runloop suspends and wakes on a request (Pro), and builds blueprints for arm64.
Use Together Code Sandbox when
you already run models on Together and want light sandboxes 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
If your agents do real work for hours, installing, building, testing, running Docker or an emulator and serving apps, look at boat. Each sandbox is a full VM you can sign up for today, with faster CPUs than Runloop, files kept on every plan, and the agent and its keys already set up.
A whole machine with /dev/kvm
Neither Runloop nor Together documents nested virtualization, so Android emulators and VM-based tests do not start. Together's new SDK also runs commands as a normal user and does not document Docker inside.
Files kept on every plan
A Runloop devbox is gone once it shuts down unless you pay for the Pro plan's suspend or write snapshot code. Together's Code Interpreter keeps nothing after its 60-minute session. boat saves the disk every minute.
Private hosting and a desktop
On Together every port is public, there is no SSH and no desktop. Runloop gives one HTTPS tunnel and no raw TCP. boat serves token-protected HTTPS on 50 ports, raw TCP and a 60fps desktop.
Use boat when your agents do real work for hours: installs, builds, Docker, emulators, a browser and servers other people reach, on a full machine with files kept on every plan. Compare it one to one: boat vs Runloop and boat vs Together Code Sandbox.
Questions people ask
Is Runloop cheaper than Together Code Sandbox?
Together's only self-serve price is Code Interpreter, which does not fit these scenarios because sessions end after 60 minutes and keep no disk. It looks cheaper for 50 agents, $264 against $5,268 a month on Runloop, but costs more for 1,000 short jobs at once: $6,000 against $3,184. boat costs $317 and $2,000 for those two.
Which is faster, Runloop or Together Code Sandbox?
Only Runloop has a measured CPU score: 8.29 runs a second on the Node.js build-and-test loop at 4 vCPU / 8 GB. Together was not part of that run. boat scored 26.69 on the same test.
Can Runloop and Together Code Sandbox run Docker?
Runloop runs Docker inside on its Docker-in-Docker blueprints, as root. Together builds sandboxes from Docker images, but its new SDK does not document Docker inside a sandbox. boat runs Docker, systemd and root on every machine.
Can I sign up for Together Code Sandbox today?
The VM SDK and CLI must be enabled for your organization, so you ask Together for access. Code Interpreter is self-serve on prepaid credits. Runloop and boat both let you sign up and start a sandbox right away.
Which one saves a sandbox's memory?
Together can end a sandbox with a snapshot of its disk and memory, so new sandboxes come back with processes running. Runloop keeps the disk through suspend on Pro or through disk snapshots. boat saves the disk every minute, and resuming boots the machine again.
Can I limit which websites a sandbox can reach?
On Runloop, yes: network policies allow only the hostnames you list, or block everything. Together documents only an experimental inbound allowlist. boat has no provider-side egress allowlist, so you filter inside the VM.
Try boat
Install the CLI, then run boat new.
7-day free trial