Fly.io Machines vs Together Code Sandbox
Fly.io Machines are microVMs for hosting your own apps in 17 regions, with wake on request and one Volume for lasting data. Together Code Sandbox is a sandbox for model-written code that saves disk and memory as snapshots to branch from, but Together must enable it for your organization.
The companies and products
Fly.io Machines
Fly.io is an app hosting platform, and Machines are the microVMs underneath it that you can also start and stop through a REST API.
A Fly Machine boots your Docker image as a Firecracker microVM on Fly's own servers, in one of 17 regions. You pick a shared or performance CPU preset, attach at most one Volume for data that must last, and Fly Proxy can stop, suspend and wake Machines as traffic comes and goes. It is built for teams that host web apps and services worldwide; it is not a sandbox product, so this page compares the parts that overlap with agent work.
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. “92nd cheapest of 367” means 91 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 | Fly.io Machines: 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 Fly lets you install Docker as root in your own image, while Together's new SDK documents no Docker inside; boat has Docker, systemd and /dev/kvm on every machine. | 92nd of 367, with limits $836 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 Fly Proxy can stop idle Machines and wake them on traffic, while Together has no idle detection or wake on request; boat keeps the whole disk of a long-lived agent. | 125th of 366, with limits $816 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 Fly fits short bursts well with per-second billing and no plan fee; Together's Code Interpreter bills per 60-minute session and runs only Python. | 75th of 345, with limits $94 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 Fly gives each user a Machine with HTTPS through Fly Proxy, while every Together port is public and preview URLs are coming soon; boat token-protects each URL. | 69th of 361, with limits $600 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 start many sandboxes from one memory snapshot, which suits rollouts from a warm state, but the VM product needs Together to turn it on. | 48th of 360, with limits $2,838 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 | 117th of 364, with limits $457 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 keeps the CPU busy, which drains a shared Fly vCPU's burst balance; Together's self-serve Code Interpreter runs only Python, so it is not a CI runner. | 152nd of 377, with limits $288 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 | 118th of 368, with limits $53 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 Neither Fly nor Together ships a desktop or browser, so you build one into your image; boat streams a 60fps desktop with Chromium. | 95th of 369, with limits $173 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 | 160th of 367, with limits $90 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 | 161st of 346, with limits $67 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 Fly ranks well here because it can spread scrapers across 17 regions and bill only the seconds they run. | 44th of 338, with limits $1,232 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 | 118th of 360, with limits $63 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 | Fly.io Machines | Together Code Sandbox | boat |
|---|---|---|---|
| Kind of product | App hosting platform; Machines are its microVM building block with a REST API | Code sandbox on an AI cloud, aimed at model-generated code, agent tool calls and RL rollouts | Agent sandbox: a full VM per agent, ready to use |
| Getting started | Self-serve sign-up with a free trial of 2 Machine hours or 7 days | The SDK and CLI must be enabled for your organization by Together; only Code Interpreter is self-serve | Sign up and start a sandbox from the API, CLI or dashboard |
| Isolation | Firecracker microVM with its own kernel | A VM per sandbox on Together's infrastructure | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker, root and systemd | Root, and Docker you install yourself; Fly's own init, no systemd | 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 not offered | Not documented | /dev/kvm for Android emulators and nested VMs |
| Files after a stop | Root file system is ephemeral; one Volume per Machine, billed for its full size around the clock | Save the disk as a snapshot when a sandbox ends; disk size is fixed | Whole disk kept, saved every minute and on stop; a stopped sandbox costs nothing |
| Memory snapshots | Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move | Save disk and memory when a sandbox ends; new sandboxes resume with processes running | No memory snapshots; resume boots from disk |
| Fork | Clone copies a Machine's config; a cloned Volume starts empty | No live fork: the parent stops, then many sandboxes start from its snapshot | Fork a running sandbox, disk included; the original keeps running |
| Idle and wake | Fly Proxy stops or suspends idle Machines and wakes them when a request arrives | 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 and TCP through Fly Proxy, Anycast IPs, custom domains, private network | All ports public; preview URLs coming soon; experimental inbound allowlist | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Shell access | SSH into a Machine | Commands, shells and files through the SDK and CLI; no SSH | SSH, plus exec and files over the API |
| Desktop and browser | None built in; you add them to your image | None; headless command and file access only | 60fps Linux desktop with Chromium, computer use and browser control |
| Coding agents and keys | Install agents yourself; secrets as environment variables, or deploy Fly's open-source tokenizer | Run your own agent through execs; no credentials proxy documented | Claude Code, Codex and more preinstalled, driven from outside; credentials proxy for any HTTPS API |
| Regions | 17 regions on six continents | Not published | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Fly.io Machines | 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 | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | 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 | Yes | No | Yes |
| Public IPv4 | Yes | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | 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 | No | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Fly.io Machines or Together Code Sandbox: neither was part of the public StarSling run where boat did 26.69 Node.js runs per second at 4 vCPU / 8 GB. Fly's results would depend on its CPU class, since shared vCPUs guarantee only 6.25% of each core with a burst balance and performance vCPUs get the full core.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Fly.io Machines 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 | Fly.io Machines, 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 | $15 · Pay As You Go · with limits | $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 | $36 · 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 | $487 · Pay As You Go · with limits | $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 | $110 · Pay As You Go · 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 | $232 · Pay As You Go · with limits | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
Fly.io Machines: Fly bills each Machine per second while it runs, by CPU preset and memory, with no plan fee; Volumes are billed for their full size all month. The table uses Fly's lowest rate, shared vCPUs bought in 1-year reservation blocks.
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 spent per second while sandboxes run. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Both are marked a compromise in every scenario, for different reasons. Fly's lowest figures need a 1-year reservation and use shared vCPUs that guarantee 6.25% of each core, so long builds get throttled. Together's priced column is Code Interpreter, with 60-minute sessions, no lasting disk, Python only and no published machine size. On boat the 1,000-job burst is limited by starts per hour and per day, so it gets queued even on the $2,000 plan.
| Scenario | Fly.io Machines | 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 Fly.io Machines when
you host apps or light services that must run near users worldwide, sleep between requests and wake on traffic, and you are happy to build your own image.
- Runs worldwide. For agents or users outside Europe: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
- Wakes on traffic. For services that sleep between requests: Fly Proxy stops idle Machines and starts them again when a request comes in.
- Self-serve and a full app platform. For teams that also host their product: sign up today and get private networking, Anycast IPs and custom domains around each Machine.
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.
- Branch from a warm state. For rollouts and test variants: save a sandbox with its memory and start many copies with processes still running.
- Next to your models. For teams already running inference or fine-tuning on Together: sandboxes and models share one account and API key.
- Tiny machines and a Python runner. For many light jobs: sandboxes start at a tenth of a core, and Code Interpreter runs Python with no VM to manage.
Where boat fits
Fly is an app host you turn into a sandbox yourself, and Together's VM sandbox needs Together to enable it, with only Code Interpreter open to everyone. If what you are really running is coding or computer-use agents that work for hours, boat gives each one a full VM you can start today, with the tools, agents and desktop already inside.
A full machine for agent tools
Agents run Docker, services and emulators. Fly has no systemd or /dev/kvm, and Together documents neither Docker inside nor nested virtualization, so compose stacks and emulator builds stall. boat has Docker, systemd and /dev/kvm on every machine.
A disk that keeps everything
Fly resets the root file system, so caches must live on a Volume billed even while stopped. Together keeps files only if you snapshot when the sandbox ends. boat saves the whole disk every minute and on stop, and forks running sandboxes.
Agents, desktop and keys built in
On both, you build the browser, desktop and agent harness into your own image, and keys sit inside the sandbox unless you run Fly's tokenizer yourself. boat ships a 60fps desktop, preinstalled coding agents and a credentials proxy.
Use boat when your agents do real work for hours: installs, builds, Docker and emulators on a full VM whose disk survives every stop, with a desktop, coding agents and a keys proxy built in. Compare it one to one: boat vs Fly.io Machines and boat vs Together Code Sandbox.
Questions people ask
Is Fly.io Machines cheaper than Together Code Sandbox?
It depends on the job, and neither fits these scenarios fully. Together's priced column is Code Interpreter, which is lower for 50 agents in parallel, $264 against $487 a month on Fly, but higher for sandboxes for your users, $900 against $110, and for 1,000 short jobs at once, $6,000 against $232. boat is $317, $200 and $2,000 for those three.
Which is faster, Fly.io Machines or Together Code Sandbox?
Neither has a comparable CPU measurement. On Fly it depends on the CPU class you pick, since shared vCPUs guarantee 6.25% of a core and performance vCPUs get the full core. boat did 26.69 runs per second on the StarSling Node.js test at 4 vCPU / 8 GB.
Can Fly.io Machines or Together Code Sandbox run Docker?
On Fly you can install and run Docker yourself, since a Machine is a microVM with root, but there is no /dev/kvm for nested VMs. Together builds sandboxes from Docker images, but its new SDK documents neither Docker inside a sandbox nor nested virtualization. boat has Docker, systemd and /dev/kvm on every machine.
Which one keeps my files after a stop?
A Fly Machine keeps only what is on its one Volume, since the root file system is ephemeral. Together saves a sandbox's disk, and memory too, as a snapshot when it ends. boat keeps the whole disk, saved every minute and on stop.
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. Code Interpreter, a separate Python API billed per 60-minute session, is self-serve with prepaid credits. Fly.io Machines and boat are both self-serve.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Fly.io Machines
- boat vs Together Code Sandbox
- E2B vs Fly.io Machines
- Daytona vs Fly.io Machines
- Modal vs Fly.io Machines
- Vercel Sandbox vs Fly.io Machines
- Cloudflare Sandbox vs Fly.io Machines
- Blaxel vs Fly.io Machines
- Runloop vs Fly.io Machines
- Tensorlake vs Fly.io Machines
- Morph Cloud vs Fly.io Machines
- CodeSandbox SDK vs Fly.io Machines