CodeSandbox SDK vs Koyeb
Both start a sandbox as a small VM that sleeps when idle and wakes on the next request. CodeSandbox SDK keeps memory and disk through hibernation and forks from live state, while Koyeb adds GPUs, outbound traffic rules and regions in the US and Asia.
The companies and products
CodeSandbox SDK
CodeSandbox SDK is an API from CodeSandbox, now a Together AI company, that starts sandboxed development VMs on the same infrastructure as the CodeSandbox editor.
Each sandbox is a Firecracker microVM built from a template or any Dockerfile. When it goes idle it hibernates with a memory snapshot, and it resumes or forks from that snapshot in seconds. You drive it from a TypeScript SDK through terminals, commands, files and HTTPS hosts. Together's docs now call it the legacy offering and point new users to its successor, the together-sandbox SDK.
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.
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. “46th cheapest of 345” means 45 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 | CodeSandbox SDK: price rank | Koyeb: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker and a disk that lasts; CodeSandbox SDK keeps its disk through hibernation, Koyeb loses local disk on redeploy, and bochka ranks 3rd with a full VM. | 178th of 367, with limits $1,939 a month | 54th of 367, with limits $366 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 one machine all month needs its files kept; CodeSandbox SDK keeps them, Koyeb needs a volume, and bochka keeps the disk and saves it every minute. | 215th of 366, with limits $2,478 a month | 135th of 366, with limits $923 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 Both suit short code runs that sleep between uses; Koyeb ranks 4th here and CodeSandbox SDK 46th, while bochka's start limits make bursts a compromise. | 46th cheapest of 345 $642 a month | 4th cheapest of 345 $66 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 this well and wakes a user's sandbox on request; CodeSandbox SDK's Scale plan stops at 250 VMs at once, and bochka ranks 1st. | 140th of 361, with limits $1,707 a month | 6th cheapest of 361 $495 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 CodeSandbox SDK can fork a running VM that shares memory with its parent, so many rollouts branch from one warm state. | 348th of 360, with limits $3,861 a month | 237th of 360, with limits $1,631 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 | 64th cheapest of 364 $1,335 a month | 19th cheapest of 364 $429 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 jobs that build Android apps or VM images need /dev/kvm, which bochka exposes and neither CodeSandbox SDK nor Koyeb documents. | 92nd cheapest of 377 $860 a month | 142nd of 377, with limits $88 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 310th of 368, with limits $240 a month | 217th of 368, with limits $37 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; neither CodeSandbox SDK nor Koyeb has one, while bochka streams a 60fps Linux desktop with Chromium. | 206th of 369, with limits $691 a month | 81st of 369, with limits $123 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 | 251st of 367, with limits $443 a month | 172nd of 367, with limits $123 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 | 281st of 346, with limits $508 a month | 172nd of 346, with limits $89 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 | 193rd of 338, with limits $7,390 a month | 65th of 338, with limits $1,683 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 | 240th of 360, with limits $326 a month | 233rd of 360, with limits $299 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 Only Koyeb runs GPUs here, from RTX 4000 cards up to H100 and H200; CodeSandbox SDK and bochka are CPU only. | Can't run it | 3rd cheapest of 98 $628 a month | 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 | CodeSandbox SDK | Koyeb | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | MicroVM per instance | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Biggest machine | Up to 16 cores / 32 GB on Scale, 64 cores / 128 GB on Enterprise | Instance types up to 40 vCPU / 128 GB, and GPU types far larger | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Sleep and wake | Hibernates with a memory snapshot after an idle timeout; an HTTP request wakes it with processes still running | Scales to zero after at least 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Disk that survives | 20 GB disk kept through hibernation | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, Frankfurt and Washington) persist | Disk is kept across stops and saved every minute, with snapshots |
| Fork | Fork a hibernated sandbox from its snapshot, or a running one sharing its memory | SDK snapshots of the filesystem or running processes, then new sandboxes from them (experimental) | Fork a running sandbox with its disk |
| Docker and root | Docker and root; built from any Dockerfile | Starts from any Docker image | Docker, systemd and root |
| Nested virtualization | Not documented | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Shell access | Terminals, commands and files through the SDK; no SSH | Commands and files through Python or JavaScript SDKs; no SSH | SSH, plus exec and files over the API |
| Inbound access | HTTPS host per port, public by default; no raw TCP or public IP | One exposed HTTPS port at a time, plus an optional TCP proxy to one port; no dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | No provider-side allowlist | Block all outbound traffic, or allow only listed IPs and CIDRs | Open internet, no provider-side allowlist |
| Desktop and browser | No desktop; a headless Chromium template | No desktop or browser in the sandbox SDK | 60fps Linux desktop with Chromium and computer use |
| Coding agents | Run your own agent through the command API | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb | Claude Code, Codex and others preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets passed in as environment variables | Secrets set as environment variables inside the service | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs and regions | No GPUs; a country hint steers scheduling but placement is not guaranteed | RTX 4000 SFF Ada up to H100 and H200; regions in the EU, US and Asia | No GPUs; EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | CodeSandbox SDK | Koyeb | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | 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 | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Not published | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for CodeSandbox SDK or Koyeb: 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. CodeSandbox SDK and Koyeb 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 | CodeSandbox SDK, a month | Koyeb, 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 | $193 · Scale | $29 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $341 · Scale | $57 · Pro | $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,500 · Scale | $475 · Pro | $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 | $815 · Scale · with limits | $329 · Scale | $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,632 · Scale · with limits | $485 · Scale · with limits | $2,000 · $2000/mo · with limits |
CodeSandbox SDK: You buy VM credits and each size burns a fixed number per hour, billed per started minute while the VM runs, including the idle time before it hibernates. Scale adds a $170 monthly platform fee that is not usage credit, and a hibernated VM costs nothing.
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 with $100 included, and bandwidth above 1 TB is extra.
Koyeb: 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
CodeSandbox SDK's Scale plan allows 250 VMs at once, so the user-sandboxes and 1,000-job scenarios do not fit it without Enterprise, and its price for egress and for disk beyond 20 GiB is not published. Koyeb's 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, which throttles the 1,000-job burst. bochka fits every scenario except that burst, where even its $2,000 plan queues starts above 90 a minute.
| Scenario | CodeSandbox SDK | Koyeb | 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 CodeSandbox SDK when
your sandboxes sleep between visits and must wake with their memory and processes intact, or when you fork many runs from one live state, and you are fine building on what Together now calls its legacy SDK.
- Hibernation that keeps memory. For sandboxes that sleep between visits: an HTTP request wakes the VM with its memory and running processes intact.
- Forks from live state. For branching many runs from one warm state: fork a running sandbox that shares memory with its parent.
- A disk that survives sleep. For work that must keep its files: a hibernated sandbox keeps its disk, with no volume to set up.
Use Koyeb when
your sandboxes need GPUs, outbound traffic rules, or regions in the US and Asia, or when they sit next to apps you already host on Koyeb.
- GPUs on the same platform. For agents or evals that need a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
- Regions in the US and Asia. For sandboxes that must run near users outside Europe: Frankfurt, Paris, Washington D.C., Singapore, Tokyo and more.
- Outbound traffic rules. For running untrusted code: the SDK can cut a sandbox off from the internet or allow only listed IPs.
Where bochka fits
CodeSandbox SDK and Koyeb are both built around sandboxes that sleep and wake fast. If what you are really running is agents that work for hours on builds, Docker, emulators, a browser and servers other people reach, bochka gives each one a full machine with the agent and its keys already set up.
A whole machine with /dev/kvm
Neither CodeSandbox SDK nor Koyeb offers SSH or documents nested virtualization, so Android emulators and VM-based tests cannot start. bochka gives root, systemd, Docker, SSH and /dev/kvm in every sandbox.
Agents, desktop and keys built in
On both, you build the agent harness on top of a command API, add your own browser, and pass keys as environment variables the agent can read. bochka preinstalls Claude Code and Codex, streams a 60fps desktop, and keeps keys in a credentials proxy.
Hosting beyond one HTTPS port
Koyeb exposes one HTTPS port at a time and CodeSandbox SDK serves HTTPS only, public by default. bochka serves up to 50 token-protected HTTPS ports plus raw TCP on a dedicated IP, so a dev server, an API and a database all stay reachable.
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 CodeSandbox SDK and bochka vs Koyeb.
Questions people ask
Is CodeSandbox SDK cheaper than Koyeb?
Not in these scenarios. One agent that never stops costs $341 a month on CodeSandbox SDK against $57 on Koyeb, and 50 agents in parallel cost $2,500 against $475. bochka comes to $26 and $317 for the same two.
Which is faster, CodeSandbox SDK or Koyeb?
Neither has a comparable CPU measurement, so there is no fair speed ratio between them. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks Node.js loop at 4 vCPU / 8 GB.
Can CodeSandbox SDK and Koyeb run Docker?
CodeSandbox SDK builds sandboxes from any Dockerfile and runs Docker with root inside, and Koyeb starts sandboxes from any Docker image. Neither documents /dev/kvm, which bochka exposes for Android emulators and VMs.
Does a Koyeb sandbox keep its files like CodeSandbox SDK?
Not by default. Koyeb's local disk is lost on redeploy and a deep sleep discards the VM, so lasting files need a volume or an SDK snapshot. CodeSandbox SDK keeps the disk and memory through hibernation.
Are CodeSandbox SDK and Koyeb still independent?
CodeSandbox is now part of Together AI, whose docs call the CodeSandbox-based SDK deprecated and name together-sandbox as its successor. Koyeb agreed to join Mistral AI on February 17, 2026, and says its platform keeps running as part of Mistral Compute.
Does either have GPUs?
Koyeb does, from an RTX 4000 SFF Ada up to H100 and H200, billed per second. CodeSandbox SDK and bochka are CPU only.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs CodeSandbox SDK
- bochka vs Koyeb
- E2B vs CodeSandbox SDK
- Daytona vs CodeSandbox SDK
- Modal vs CodeSandbox SDK
- Vercel Sandbox vs CodeSandbox SDK
- Cloudflare Sandbox vs CodeSandbox SDK
- Blaxel vs CodeSandbox SDK
- Runloop vs CodeSandbox SDK
- Tensorlake vs CodeSandbox SDK
- Morph Cloud vs CodeSandbox SDK
- CodeSandbox SDK vs Northflank