Freestyle vs Together Code Sandbox
Both start VMs from snapshots and can bring a sandbox back with its memory. Freestyle sells full KVM VMs anyone can sign up for, with Docker, nested virtualization, live fork and wake on request, while Together's VMs must be enabled for your organization and sit next to its model cloud.
The companies and products
Freestyle
Freestyle sells full Linux virtual machines for AI agents, built for long running, complex tasks.
Each Freestyle VM is a KVM virtual machine with its own kernel, booted from an Ubuntu base snapshot with systemd, Docker and coding agent CLIs preinstalled. VMs can be paused with their memory, snapshotted while running, forked and woken by the next request, and every VM starts behind a default-deny firewall. It is built for teams that give each agent or each user its own machine, driven from a TypeScript SDK, a CLI or an API.
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. “40th cheapest of 345” means 39 of the other 344 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 | Freestyle: 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 Freestyle runs Docker, systemd and nested virtualization, which Together's new SDK does not document; bochka has all three on CPUs that did 2.8 times Freestyle's work on the benchmark. | 241st of 367, with limits $3,311 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 lives on its machine all month fits Freestyle once you leave the Free plan; Together has no idle detection or wake on request, and its self-serve Code Interpreter ends after 60 minutes. | 263rd of 366, with limits $4,195 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 Freestyle fits short code runs well, with VMs that pause with their memory and wake on the next request; Together's Code Interpreter runs only Python, in 60-minute sessions that keep nothing. | 40th cheapest of 345 $482 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 Freestyle wakes a paused user VM on its next request and serves it on HTTPS with forward auth, while on Together every port is public and preview URLs are listed as coming soon. | 16th cheapest of 361 $1,358 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 Both can start many copies from a snapshot with memory; Freestyle also clones a running VM without stopping it, while Together stops the parent first. | 107th of 360, with limits $6,600 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, Freestyle preinstalls coding agent CLIs, and bochka adds an API to prompt, steer and follow each run. | 53rd cheapest of 364 $1,046 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 | 168th of 377, with limits $625 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 | 98th cheapest of 368 $151 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 ships a desktop: Freestyle has guides to install one with VNC yourself and Together offers headless access only, while bochka streams a Linux desktop at 60fps. | 234th of 369, with limits $940 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 bochka has Chromium on a desktop in every sandbox; on Freestyle you follow a guide to install Chromium and a display, and on Together you bake a browser into your own image. | 257th of 367, with limits $482 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 | 278th of 346, with limits $482 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 | 183rd of 338, with limits $6,560 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 | 272nd of 360, with limits $482 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 | Freestyle | Together Code Sandbox | bochka |
|---|---|---|---|
| Isolation | Full KVM VM 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 |
| Getting started | Sign up on the Free plan; Hobby, Pro and Enterprise above it | The VM 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 |
| CPU benchmark (4 vCPU / 8 GB) | 9.64 runs/s | Not measured | 26.69 runs/s |
| Root, systemd and Docker | Yes; systemd is pid 1 and Docker runs from boot | Commands run as user 1000 by default, root on request; Docker inside not documented | Docker, systemd and root on every machine |
| Nested virtualization | Yes, full KVM support | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Machine size | Up to 4 vCPU / 8 GiB on Free, 32 / 64 on Pro, 64 / 128 with custom limits | 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 / 32 on the $100 plan and above |
| Saving memory | Pause saves memory and disk; the same processes resume where they left off | End a sandbox with a snapshot of its disk, or disk and memory; a new sandbox resumes with its processes running | Disk saved every minute and on stop; resume boots the machine again |
| Fork | Clone a running VM without pausing it; snapshots capture memory and disk | No live fork: the parent stops, then you start many sandboxes from its snapshot | Fork a running sandbox with its disk; the original keeps running |
| Idle and wake | Optional idle timeout; a paused VM resumes on the next traffic that reaches it | 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 on free style.dev names or your own domain, forward auth, other public protocols | 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 |
| Outbound rules | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Open internet | Open internet, no provider-side allowlist |
| Desktop and browser | Guides to install GNOME or Xvfb, VNC and Chromium yourself | None; headless command and file access only | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | claude, codex, opencode and openclaw preinstalled, driven through exec or a terminal | Run your own agent through execs; a Harbor guide for agent evals | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Credentials injected at the edge for HTTPS headers, Postgres and S3 | No credentials proxy documented | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
Every feature Battleships tracks (43)
| Feature | Freestyle | Together Code Sandbox | bochka |
|---|---|---|---|
| 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 | 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 | Yes | 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 | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | 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 | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Not published | 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 hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, Freestyle did 9.64 runs per second and bochka did 26.69, so bochka finished about 2.8 times as much CPU work. There is no comparable measurement for Together Code Sandbox, which was not part of that run.
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 | Freestyle, 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 | $27 · Free | $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 | $159 · Free | $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,139 · Pro | $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 | $581 · Pro | $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,305 · Pro · with limits | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
Freestyle: Freestyle bills per second for the vCPU, RAM and disk allocated to a VM, busy or idle, after monthly allowances of 200 vCPU-hours, 400 GiB-hours of RAM and 60,000 GiB-hours of storage. On Free those allowances are hard stops; Hobby and Pro set a $50 or $500 monthly minimum that counts as usage.
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, its only self-serve product with a published price: $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. 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, and its limits decide every row: sessions last 60 minutes, nothing is kept after a session, it runs only Python and its machine size is not published. Freestyle fits every scenario except 1,000 short jobs at once, because Pro allows 400 concurrent VMs, and it has no idle timeout by default, so a VM bills until you pause it. bochka fits all but the 1,000-job burst too, where its $2,000 plan queues starts above 90 a minute.
| Scenario | Freestyle | Together Code Sandbox | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| None that bite |
| One agent that never stops | None that bite |
| None that bite |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users | None that bite |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Freestyle when
you want full VMs today with Docker and nested virtualization, VMs that pause with memory and wake on the next request, a default-deny firewall, or more than 16 vCPU in one machine.
- Full VMs you can sign up for today. For agents that need Docker, systemd or Android emulators, Freestyle VMs have all three and start on a free plan.
- Live fork and wake on request. For VMs that sleep between requests, Freestyle clones them while running and wakes a paused one on the next incoming traffic.
- Network controls. Every VM starts behind a default-deny firewall, while on Together every port of a sandbox is public by default.
Use Together Code Sandbox when
you already run models on Together and want very light sandboxes you can save with their memory and branch from, or a simple Python runner billed per session.
- 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. For many light jobs, a Together sandbox can be as small as a tenth of a core.
- A Python runner with no VM to manage. For plain Python snippets, the Code Interpreter API runs code in sessions billed per 60 minutes from prepaid credits.
Where bochka fits
If your agents do real work for hours, like installs, builds, tests, Docker, emulators and a browser, look at bochka. It gives each agent a full VM you can start today, on faster CPUs, with a desktop, private hosting and an API to drive the agents inside from outside.
Faster CPUs for every build
bochka did 26.69 runs per second on the CPU benchmark against 9.64 for Freestyle, which says it oversubscribes its hosts. Together was not measured, and its only self-serve product is a Python runner that ends after 60 minutes.
A desktop and a browser, ready
A computer-use agent needs a screen. On Freestyle you install GNOME or Xvfb, VNC and Chromium yourself and build the click layer, and Together offers headless access only.
Agents driven from outside, keys kept out
Neither has an API to prompt and steer the coding agents inside, so you parse exec output yourself. On Together, keys you pass in sit inside a machine the agent controls, with no credentials proxy.
Use bochka when your agents do real work for hours: builds, tests, Docker, emulators, a desktop and a browser, on fast CPUs, with an API to drive the agents inside from outside. Compare it one to one: bochka vs Freestyle and bochka vs Together Code Sandbox.
Questions people ask
Is Freestyle 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 small runs, but costs more at scale: sandboxes for your users are $581 a month on Freestyle against $900 on Together, and bochka is $200.
Which is faster, Freestyle or Together Code Sandbox?
Freestyle did 9.64 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, and Together has no comparable measurement. bochka did 26.69 on the same test, about 2.8 times Freestyle's work.
Can Freestyle and Together Code Sandbox run Docker?
Freestyle runs Docker from boot with systemd as pid 1, plus full KVM support for Android emulators. 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.
Can I sign up for Together Code Sandbox today?
Not for the VMs: the together-sandbox SDK and CLI must be enabled for your organization by Together. Code Interpreter is self-serve from prepaid credits. Freestyle and bochka both let you sign up and start a VM right away.
Do both save a sandbox with its memory?
Yes, in different ways. Freestyle pauses a VM with its memory, clones it while running and wakes it on the next request. Together saves memory when a sandbox ends, then starts new sandboxes from that snapshot with processes running. bochka saves the disk every minute and on stop, but resuming boots the machine again.
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