Koyeb vs Together Code Sandbox
Koyeb sandboxes are microVMs you can sign up for today, which sleep when idle, wake on a request and can run on GPUs. Together Code Sandbox starts VMs from Docker-image snapshots and can save their memory when they end, but Together has to enable it for your organization.
The companies and products
Koyeb
Koyeb is a serverless cloud for apps, inference and sandboxes, and in February 2026 it agreed to join Mistral AI.
A Koyeb sandbox is a Koyeb service: a microVM started from any Docker image and driven from Python or JavaScript SDKs that run commands, read files and expose a port. It can scale to zero when idle and wake on the next request, and it can run on CPU or GPU instance types. It is built for teams that run AI agents or untrusted code next to apps they already host on Koyeb.
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. “4th cheapest of 345” means 3 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 | Koyeb: 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 | 54th of 367, with limits $366 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 | 135th of 366, with limits $923 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 Koyeb fits short code runs well with small instances that scale to zero and wake on a request; Together's Code Interpreter runs only Python, billed per 60-minute session. | 4th cheapest of 345 $66 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 Koyeb fits and wakes a sleeping sandbox on a request, while on Together every port is public and preview URLs are still listed as coming soon; bochka gives each user token-protected HTTPS on up to 50 ports. | 6th cheapest of 361 $495 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, but the VM product needs Together to enable it. | 237th of 360, with limits $1,631 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 and Koyeb offers tutorials on its command API; bochka ships the coding agents themselves, with an API to prompt, steer and follow each run. | 19th cheapest of 364 $429 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 that builds Android apps or VM images needs /dev/kvm, which bochka exposes and neither Koyeb nor Together documents. | 142nd of 377, with limits $88 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 | 217th of 368, with limits $37 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 desktop, and neither Koyeb nor Together Code Sandbox has one; bochka streams a 60fps Linux desktop with Chromium. | 81st of 369, with limits $123 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 On Koyeb and on Together you install and run a headless browser in your own image; bochka ships Chromium on a desktop in every sandbox. | 172nd of 367, with limits $123 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 | 172nd of 346, with limits $89 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 | 65th of 338, with limits $1,683 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 | 233rd of 360, with limits $299 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 Koyeb runs GPU instances from small RTX cards up to H100 and H200, while Together Code Sandbox and bochka have no GPU sandboxes. | 3rd cheapest of 98 $628 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 | Koyeb | Together Code Sandbox | bochka |
|---|---|---|---|
| Isolation | MicroVM per instance | 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 Pro and Scale plans | The SDK and CLI must be enabled for your organization by Together | Sign up and start a sandbox from the API, CLI or dashboard |
| Machine size | Instance types up to 40 vCPU / 128 GB, and GPU types far larger | 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 |
| Docker, root and systemd | Starts from any Docker image; root and systemd not documented | 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 |
| Disk that survives | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, Frankfurt and Washington) persist | Disk is saved only as a snapshot when the sandbox ends | Disk is kept across stops and saved every minute, with snapshots |
| Memory snapshots | SDK snapshots of the filesystem, or with running processes (experimental) | End a sandbox with a snapshot of its disk and memory; new sandboxes resume with processes running | No memory snapshots; resume boots the machine again |
| Fork | New sandboxes from an SDK snapshot (experimental) | 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 |
| Sleep and wake | Scales to zero after 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms | Time to live counts from creation; no idle detection and no wake on request | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Inbound access | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | 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 |
| Shell access | Commands and files through the Python and JavaScript SDKs; no SSH | Commands, interactive shells and files through the SDK and CLI; no SSH | SSH, plus exec and files over the API |
| Desktop and coding agents | No desktop; tutorials run agents through the command API | No desktop; run your own agent through execs, with a Harbor guide for evals | 60fps Linux desktop with Chromium, and Claude Code, Codex and more preinstalled with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are set as environment variables inside the service | No credentials proxy documented | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs and regions | RTX 4000 SFF Ada up to H100 and H200; EU, US and Asia | No GPU sandboxes; regions not published | No GPUs; EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Koyeb | Together Code Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | 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) | Not published | 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 | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | 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 | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | 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 Koyeb or for Together Code Sandbox: neither was part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores, so its speed depends on how busy the host is.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Koyeb 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 | Koyeb, 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 | $29 · Pro | $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 | $57 · Pro | $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 | $475 · 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 | $329 · Scale | $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 | $485 · Scale · with limits | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · with limits | $2,000 · $2000/mo · with limits |
Koyeb: Koyeb bills each instance per second at a fixed price per instance type, and Deep Sleep costs nothing. Pro costs $29 a month with $10 of usage included and Scale $299 a month with $100 included; the rest of the fee is not credit.
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 instead: $0.03 per 60-minute session from prepaid credits. It runs only Python and keeps no disk, so it does not fit these scenarios.
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, and the machine size is not published. Koyeb fits four of the five scenarios, but its priced shape is eco-xlarge, with a 20 GiB disk and no published price for more, and eco instances guarantee only half of each vCPU. At 1,000 short jobs at once nothing fits as priced: Koyeb's burstable CPU throttles under load, and bochka's $2,000 plan queues starts above 90 a minute.
| Scenario | Koyeb | 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 |
| 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 Koyeb when
you want self-serve sandboxes today that sleep when idle and wake on a request, need GPUs, or have to run in the US or Asia.
- Sign up and start today. Koyeb sandboxes are self-serve on the Pro and Scale plans, while Together has to enable its VM product for you.
- Sleep when idle, wake on request. Good for sandboxes that sit idle: Koyeb scales to zero after 5 minutes and wakes on the next request.
- GPUs and many regions. Useful when an agent needs a GPU or must run in the US or Asia: Koyeb offers both on one platform.
Use Together Code Sandbox when
you already run models on Together and want light sandboxes, from a tenth of a core, that you can save with their memory and branch from.
- 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 your sandboxes run coding agents for hours, both Koyeb and Together leave you to build the machine around the agent. bochka gives each agent a full VM that keeps its disk, with Docker, /dev/kvm, a desktop, hosting and the agents themselves built in, and you can start it today.
A whole machine, with Docker and /dev/kvm
Neither Koyeb nor Together documents nested virtualization, and Together runs commands as a normal user without documenting Docker inside. Android emulators, VM tests and compose stacks then fail or have to run somewhere else.
A disk that stays, and forks of a running machine
On Koyeb a redeploy or deep sleep loses the local disk unless you add a preview volume of up to 10 GB. On Together the disk is saved only when the sandbox ends, and to copy it the parent has to stop.
Agents, desktop and private hosting built in
Koyeb exposes one port at a time and Together makes every port public, and neither has a desktop or a credentials proxy. You build the agent harness yourself and keep API keys inside a machine the agent controls.
Use bochka when your agents do real work for hours on a machine that keeps its disk: builds, Docker, emulators, a desktop browser and preview servers, with agents and keys handled for you. Compare it one to one: bochka vs Koyeb and bochka vs Together Code Sandbox.
Questions people ask
Is Koyeb cheaper than Together Code Sandbox?
Together's only self-serve price is Code Interpreter, which fits none of these scenarios because sessions end after 60 minutes and keep no disk. It looks lower for one agent that never stops, $22 against $57 a month on Koyeb, but costs more at scale: $900 against $329 for sandboxes for your users.
Which is faster, Koyeb or Together Code Sandbox?
Neither has a comparable CPU measurement, since neither was part of the benchmark run. Koyeb guarantees at least 0.25 dedicated vCPU per GB of memory and bursts to all cores. bochka did 26.69 runs per second on the same test at 4 vCPU / 8 GB.
Can I run Docker and Android emulators in each?
Both start sandboxes from Docker images, but neither documents nested virtualization, and Together does not document Docker inside a sandbox. bochka runs Docker, systemd and root on every machine and exposes /dev/kvm for Android emulators and VMs.
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 is self-serve with prepaid credits. Koyeb sandboxes are self-serve on the Pro and Scale plans.
Do Koyeb and Together keep a sandbox's files?
Koyeb loses the local disk on redeploy and a deep sleep discards the VM, so lasting files need a volume (in preview) or an SDK snapshot. Together saves the disk, and memory too, only as a snapshot when the sandbox ends. bochka keeps the disk across stops and saves it every minute.
Which one has GPUs?
Koyeb runs instances from an RTX 4000 SFF Ada up to H100 and H200, billed per second. Together Code Sandbox has no GPU sandboxes, and bochka is CPU only.
Try bochka
Install the CLI, then run bochka new.
Product preview