exe.dev vs Together Code Sandbox
exe.dev rents Linux VMs you keep, reach over SSH and boot from your own Docker image, in nine regions. Together Code Sandbox starts VMs from snapshots through an SDK, can save their memory when they end, and must be turned on for your organization by Together.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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. “15th cheapest of 366” means 14 of the other 365 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 | exe.dev: 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 | 253rd of 367, with limits $3,701 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 exe.dev fits an always-on assistant fully, with a VM that runs until you stop it; Together sandboxes have no idle detection or wake on request, so your backend starts and stops them. | 15th cheapest of 366 $3,833 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 Together's Code Interpreter runs short Python sessions billed per 60 minutes, and exe.dev is not built for many tiny runs, so both are compromises here. | 235th of 345, with limits $175 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 Neither fits sandboxes for your users: exe.dev Personal stops at 50 VMs at once, and every Together port is public; boat fits with token-protected HTTPS URLs. | 257th of 361, with limits $1,226 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; boat ranks far higher here on the generated table. | 265th of 360, with limits $5,250 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 Together documents a Harbor integration for agent evals, while exe.dev drives only its Shelley agent through the API; boat ships the agents with an API to prompt, steer and follow each run. | 283rd of 364, with limits $1,050 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 exe.dev standalone VMs bill per second and pools bill whether used or not; Together's VMs are gated, and boat bills per second only while a sandbox runs. | 288th of 377, with limits $504 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 exe.dev is a real 24/7 dev box with SSH and a disk that lasts; Together has no SSH, and boat matches exe.dev here and adds a desktop in the browser. | 25th cheapest of 368 $35 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 Computer-use agents need a screen, and neither exe.dev nor Together has one; boat streams a 60fps desktop with Chromium. | 240th of 369, with limits $1,055 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 | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 | exe.dev | Together Code Sandbox | boat |
|---|---|---|---|
| Isolation | KVM VM with Cloud Hypervisor; you can't choose the kernel | A VM per sandbox on Together's infrastructure | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Getting started | Sign up for a Personal or Work plan | The SDK and CLI must be enabled for your organization by Together | Sign up and start a sandbox from the API, CLI or dashboard |
| Shell access | SSH, brokered through exe.dev | Commands, interactive shells and files through the SDK and CLI; no SSH | SSH, plus exec and files over the API |
| Docker, root and systemd | Root, systemd and Docker in every VM | Commands run as user 1000 by default, root on request; Docker inside not documented | Docker, systemd and root on every machine |
| Nested virtualization | Enterprise only | Not documented | Yes, /dev/kvm on every plan |
| Images | Boot from your own Docker image in about two seconds | Build a snapshot from a Docker image or Dockerfile, then start sandboxes from it | Templates from named snapshots; no Dockerfile or OCI images |
| Saving state | Disk persists and is streamed to a second server; no snapshots | End a sandbox with a snapshot of its disk, or disk and memory | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | cp copies a VM's disk and config into a new VM | No live fork: the parent stops, then many sandboxes start from its snapshot | Fork a running sandbox; the original keeps running |
| Session length | No cap; VMs run until you stop them | Sandboxes run until you end them or their time to live ends; no idle detection or wake on request | No cap on paid plans; you set the TTL |
| Inbound traffic | HTTPS proxy for ports 3000 to 9999, one of them public; no public IP or raw TCP | All ports public; preview URLs coming soon; an experimental inbound allowlist | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 |
| Desktop and computer use | Headless; no desktop or screen streaming | None; headless command and file access only | 60fps desktop and Chromium, computer use, browser control |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | Run your own agent through execs; a Harbor guide for agent evals | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Integrations inject secrets at the network edge for any HTTP host | No credentials proxy documented | Credentials proxy for model providers and any HTTPS API; switch accounts when one runs out of credits |
| Regions | 9 regions in the US, Europe, Asia and Australia | Not published | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | exe.dev | 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 | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | 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 | No | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | 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 | No | 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) | Yes | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither exe.dev nor Together Code Sandbox is in the hpc-sandbox-benchmarks run, so there is no comparable CPU measurement for either. boat did 26.69 runs per second on that Node.js test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. We don't guess how the other two would score.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev and Together Code Sandbox 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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 | $1,848 · Personal | $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 | $530 · Personal · with limits | $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 | $1,050 · Personal · with limits | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
exe.dev: Personal pools are a flat monthly fee for reserved vCPUs and memory that your VMs share, billed whether they are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
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.
Together Code Sandbox: Plans start at $20 a month, and the whole fee becomes usage credit. You pay per second while a sandbox runs, and 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 last 60 minutes, nothing is kept after, it runs only Python and the machine size is not published. exe.dev fits the single-agent and 50-agent rows, but Personal stops at 50 VMs at once, so 300 or 1,000 at once do not fit. On boat the limit that bites is starts: 1,000 short jobs at once need more starts per hour and per day than even the top plan allows, so they queue.
| Scenario | exe.dev | 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 |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want a persistent VM you reach over SSH, booted from your own Docker image, in a region near you, with SSO and roles for your team.
- A dev box you keep. For developers who want one VM to live in: SSH, root, Docker and a disk that stays, with no session cap.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- Team plan and an MCP server. Its Work plan covers a whole team with SSO and roles, and it serves an MCP server for controlling VMs.
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 you are choosing between exe.dev and Together because you run coding agents, boat sits between them: a full VM you can sign up for today, like exe.dev, with state saved while it runs and a fork of a running sandbox. It also adds what neither has: a desktop, /dev/kvm on every plan, private hosting and an API to drive agents inside from outside.
A screen your agents can use
exe.dev VMs and Together sandboxes are both headless, so an agent that must check a UI or click through a web app has nothing to look at until you build and stream a desktop yourself.
State saved every minute, and live forks
exe.dev has no snapshots, so one bad agent step can cost a session's work. Together snapshots only when a sandbox ends, so branching means stopping the parent first. boat saves every minute and forks a running sandbox.
Agents driven from outside, with private URLs
On exe.dev only Shelley takes prompts by API, and on Together you wire every step through execs while every port is public. boat prompts, steers and streams its preinstalled agents, and its HTTPS URLs are token-protected by default.
Use boat when your agents do real work for hours: builds, Docker, emulators, a desktop and a browser, with state saved every minute, live forks, private URLs and one API to drive agents inside from outside. Compare it one to one: boat vs exe.dev and boat vs Together Code Sandbox.
Questions people ask
Is exe.dev cheaper than Together Code Sandbox?
The only self-serve Together price is Code Interpreter, and it does not fit our scenarios because sessions end after 60 minutes and keep no disk. For one agent running all month exe.dev Personal is $35 a month, and boat is $26 a month. For 50 agents in parallel exe.dev is $1,848 a month and boat is $317 a month.
Which is faster, exe.dev or Together Code Sandbox?
Neither has a comparable CPU measurement in the hpc-sandbox-benchmarks run, so we can't say. boat scored 26.69 runs per second on that Node.js test at 4 vCPU / 8 GB.
Can exe.dev and Together Code Sandbox run Docker?
exe.dev VMs have root, systemd and Docker. Together builds sandboxes from Docker images, but its new SDK runs commands as a normal user by default and does not document Docker inside a sandbox. boat runs Docker, systemd and root on every machine.
Do they have snapshots?
exe.dev has none; it keeps each VM's disk on a second server, and cp copies a VM. Together can snapshot a sandbox's disk, or disk and memory, when it ends. boat saves the disk every minute and on stop, and can fork a running sandbox.
Can I sign up for Together Code Sandbox today?
The together-sandbox SDK and CLI must be enabled for your organization, so you ask Together for access. exe.dev and boat both let you sign up and start a VM yourself.
Can I run Claude Code on them?
exe.dev preinstalls Claude Code, Codex and Pi along with its Shelley agent. On Together you install your agent in your own image and run it through execs. boat preinstalls Claude Code, Codex, OpenCode and more, with an API to prompt and steer them.
Try boat
Install the CLI, then run boat new.
7-day free trial