Beam vs Together Code Sandbox
Beam is a self-serve serverless platform with fast gVisor sandboxes, CPU VMs and GPUs. Together Code Sandbox gives each sandbox a VM that can be saved with its memory, but Together must turn it on for your organization, and its only self-serve product is a Python Code Interpreter.
The companies and products
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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. “8th cheapest of 345” means 7 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 | Beam: 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 | 69th of 367, with limits $551 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 | 115th of 366, with limits $651 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 Beam fits short code runs well, with sandboxes that start in a second or two and bill per second; Together's Code Interpreter runs only Python and bills per 60-minute session. | 8th cheapest of 345 $117 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 Beam fits this with a quick container per user, while every port of a Together sandbox is public and preview URLs are listed as coming soon; bochka gives each user a full VM with token-protected HTTPS. | 3rd cheapest of 361 $290 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, and Beam can restore memory snapshots into new sandboxes too, but Together's VM product needs Together to enable it. | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 Beam supports Docker inside a sandbox with docker_enabled, Together does not document Docker inside, and only bochka exposes /dev/kvm for Android or VM image builds. | 12th cheapest of 377 $171 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 A Beam VM keeps its 50 GiB root disk while stopped and bochka saves the disk every minute, while Together sandboxes have no idle detection or wake on request. | 13th cheapest of 368 $21 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 Beam nor Together offers a desktop or browser, so you would build that yourself; bochka streams a Linux desktop at 60fps with Chromium for computer use. | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 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 Beam has GPUs from RTX 4090 up to H100, H200 and B200, while Together Code Sandbox and bochka are CPU only. | Cheapest of 98 $458 a month | 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 | Beam | Together Code Sandbox | bochka |
|---|---|---|---|
| Isolation | gVisor container by default for sandboxes; separate Beam VMs are CPU microVMs with their 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 | Self-serve: sign up and pay as you go on the Developer plan | 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 |
| Docker and systemd | Docker inside sandboxes with docker_enabled; systemd only in Beam VMs | Commands run as user 1000 by default, root on request; Docker inside not documented | Docker, systemd and root on every machine |
| Nested virtualization | Not documented | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| GPUs | GPU sandboxes and serverless GPUs up to H100, H200 and B200 | No | No, CPU only |
| Machine size | Request CPU cores and RAM per sandbox; max size unpublished | 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 vCPU / 32 GB on the $100 plan and above |
| Saving state | Filesystem image or memory snapshot of a running sandbox; a Beam VM keeps its root disk while stopped | End a sandbox with a snapshot of its disk, or disk and memory; new sandboxes resume with processes running | Disk saved every minute and on stop; a stopped sandbox costs nothing and keeps it |
| Fork | Memory snapshot of a running sandbox, restored into new sandboxes | 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 |
| Reaching the sandbox | A public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP | 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; dedicated IPv4 or IPv6 |
| Outbound rules | Block all outbound traffic, or allow up to 10 CIDR ranges, changeable while running | No egress allowlist documented | Open internet, no provider-side allowlist |
| Desktop and browser | No desktop or browser product | None; headless command and file access only | Linux desktop streamed at 60fps with Chromium and computer use |
| Coding agents | None preinstalled; you install and run them through process exec | Run your own agent through execs; a Harbor guide for agent evals | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are exposed as environment variables inside the sandbox | No credentials proxy documented | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Self-hosting | Beta9 runtime is AGPL-3.0 and free to self-host; bring your own cloud for a fee | No; the SDKs and CLI are MIT-licensed, the platform is not | No |
Every feature Battleships tracks (43)
| Feature | Beam | Together Code Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | 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 | No | Yes | Yes |
| Automatic snapshots | No | 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 | 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 | 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 | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | 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 | Not published | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Beam or Together Code Sandbox: neither has a result on the StarSling hpc-sandbox-benchmarks test, so we cannot say which is faster. bochka did 26.69 runs per second on that Node.js test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. Beam's own guide says its sandboxes cold-boot in 1 to 3 seconds.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Beam 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 | Beam, 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 | $5 · Developer | $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 | $22 · Developer | $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 | $410 · Team | $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 | $191 · Team | $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 | $259 · Team | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
Beam: Beam sandboxes bill per second for each CPU core (one core is two vCPU) and each GiB of RAM you request, until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee; Team costs $89 a month plus usage, with no usage credit, and there are no egress fees.
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 Together with Code Interpreter: $0.03 per 60-minute session from prepaid credits, with a $5 minimum purchase.
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
Beam fits all five scenarios, but its Developer plan allows 30 CPU containers at once, so 50 parallel agents need the Team plan, and it publishes no price for extra disk. The Together column is Code Interpreter, which fits none of them: sessions last 60 minutes, nothing is kept, it runs only Python and the machine size is not published. On bochka the limit that bites is starts: 1,000 short jobs at once need more starts per hour and per day than even the $2,000 plan allows, so starts are queued.
| Scenario | Beam | Together Code Sandbox | bochka |
|---|---|---|---|
| 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 Beam when
your agents or jobs need GPUs, when you want a self-serve sandbox you can start today with outbound rules, or when you must self-host the runtime.
- GPUs in the same platform. For agents or jobs that need a GPU, Beam offers GPU sandboxes and serverless GPUs from RTX 4090 to H100, H200 and B200.
- Self-serve and quick to start. You can sign up and pay as you go today, and its sandboxes cold-boot in 1 to 3 seconds by Beam's own guide.
- Open source and outbound rules. Teams that must self-host can run its AGPL-3.0 Beta9 runtime, and sandboxes can be locked to up to 10 CIDR ranges.
Use Together Code Sandbox when
you already run models on Together and want light VM sandboxes, from a tenth of a core, that 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 bochka fits
If what you are running is coding agents that work for hours, install tools, run Docker and serve apps, look at bochka. Each bochka sandbox is a full VM you can sign up for today, with /dev/kvm, private HTTPS hosting, a desktop and the agents already set up. Beam is the better pick for GPUs, and Together for memory snapshots next to your models.
A whole machine with /dev/kvm
A Beam sandbox is a gVisor container without systemd, and Together does not document Docker inside or nested virtualization. On both, Android emulators, VM-based tests and tools that expect a real kernel have nothing to start on.
Hosting that is private by default
On Beam each exposed port gets a public URL with no built-in auth, and on Together every port is public unless you write an experimental allowlist. Neither offers raw TCP, so an agent's database or game server cannot be reached.
Agents, desktop and keys built in
On Beam and Together you build the agent harness, browser and desktop into your own image and drive every step through execs. Keys sit inside a machine the agent controls, where one prompt injection can leak them; bochka keeps them in a proxy outside.
Use bochka when your agents do real work for hours: installs, builds, Docker, emulators, a browser and servers other people reach, on a full machine with the agents and their keys already set up. Compare it one to one: bochka vs Beam and bochka vs Together Code Sandbox.
Questions people ask
Is Beam 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. Beam fits every scenario and costs less at scale: $191 against $900 a month for sandboxes for your users, and $259 against $6,000 for 1,000 short jobs at once.
Which is faster, Beam or Together Code Sandbox?
Neither has a result on the StarSling hpc-sandbox-benchmarks CPU test, so we cannot compare their CPU speed. Beam says its sandboxes cold-boot in 1 to 3 seconds. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB.
Can Beam and Together Code Sandbox run Docker?
Beam supports Docker inside a sandbox with docker_enabled. Together builds sandboxes from Docker images, but its new SDK does not document Docker inside a sandbox. bochka runs Docker, systemd and root on every machine, plus /dev/kvm for emulators.
Is a Beam sandbox a VM like a Together sandbox?
Not by default. Beam's sandboxes are containers isolated with gVisor, and Beam sells separate CPU VMs with their own kernel and systemd. Each Together sandbox is a VM, and each bochka sandbox is a full VM with its own kernel and /dev/kvm.
Can I sign up for Together Code Sandbox today?
Only for Code Interpreter. The together-sandbox SDK and CLI must be enabled for your organization, so you ask Together for access. Beam and bochka are both self-serve.
Do Beam or Together Code Sandbox have GPUs?
Beam does, with GPU sandboxes and serverless GPUs up to H100, H200 and B200. Together Code Sandbox and bochka are CPU only.
Try bochka
Install the CLI, then run bochka new.
Product preview