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.

Kind of product: App hosting platform; Machines are its VM building block with a REST API
Isolation: Firecracker microVMs with hardware virtualization, on Fly's own servers
Regions: 17 regions in North America, Europe, Asia, Oceania, South America and Africa
CPU classes: Shared vCPUs guarantee 6.25% of each core with a burst balance; performance vCPUs get the full core
Storage: Root file system is ephemeral; one Volume of up to 500GB per Machine for lasting data
Free trial: 2 Machine hours or 7 days, up to 10 Machines of 2 vCPU / 4GB that stop after 5 minutes
Compliance: Lists SOC 2 Type II; a HIPAA package with a pre-signed BAA is sold as an add-on

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.

Company: Together AI, a cloud for model inference, fine-tuning and GPU clusters
Isolation: A virtual machine per sandbox on Together's infrastructure
Access: The SDK and CLI must be enabled for your organization; you ask Together for access
Machine size: 0.1 to 16 cores, 1 to 8 GB of memory per core; disk size is not configurable
History: Built on CodeSandbox, now a Together company; the CodeSandbox-based SDK is deprecated and together-sandbox is its successor
Source code: The SDKs and CLI are MIT-licensed on GitHub; the platform itself is not

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	bochka: 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; bochka 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; bochka 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; bochka 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; bochka 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	bochka
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	bochka
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

Fly.io MachinesNot measured

Together Code SandboxNot measured

bochka26.69 runs/s

There is no comparable CPU measurement for Fly.io Machines or Together Code Sandbox: neither was part of the public StarSling run where bochka 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	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	$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 bochka 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	bochka
One coding agent, workdays	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	Together pay-as-you-go (prepaid credits; Code Interpreter only): sessions capped at 1 h missing persistent disk machine size not published different kind of product: code interpreter	None that bite
One agent that never stops	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	Together pay-as-you-go (prepaid credits; Code Interpreter only): sessions capped at 1 h missing persistent disk machine size not published different kind of product: code interpreter	None that bite
50 agents in parallel	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	Together pay-as-you-go (prepaid credits; Code Interpreter only): sessions capped at 1 h missing persistent disk, Docker inside machine size not published different kind of product: code interpreter	None that bite
Sandboxes for your users	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	machine size not published different kind of product: code interpreter machine size per session not published egress price not published	None that bite
1,000 short jobs at once	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	machine size not published different kind of product: code interpreter machine size per session not published egress price not published	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

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 bochka 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, bochka 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. bochka 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. bochka 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. bochka ships a 60fps desktop, preinstalled coding agents and a credentials proxy.

Use bochka 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: bochka vs Fly.io Machines and bochka 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. bochka 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. bochka 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. bochka 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. bochka 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 bochka are both self-serve.

Is bochka SOC 2 compliant?

SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.

Try bochka

Install the CLI, then run bochka new.

Product preview