bochka vs Novita
Both give each agent its own Linux sandbox through an API. bochka gives it a full VM with Docker and nested virtualization that can run for as long as the work takes, while Novita is strongest at short jobs that pause with their memory and wake on the next request.
Where bochka stands out
A full VM with Docker and /dev/kvm
Every bochka sandbox is a full VM with its own kernel, root, systemd, Docker and /dev/kvm ready to use. Novita builds its templates from Docker images, but its docs do not cover running Docker or nested virtualization inside a sandbox.
Runs as long as the work takes
A bochka sandbox has no session cap on paid plans, and its disk is saved every minute and when it stops. On Novita a sandbox times out after 5 minutes by default and is killed unless you choose pause, and it lives at most 1 hour unless you turn on long-running mode, with 20 GB of local disk.
More CPU work in the same time
bochka runs on dedicated AMD Ryzen 9 9950X hosts. In the same Node.js build-and-test benchmark run at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Novita did 19.52, about 37% more work per second.
The companies and products
bochka
bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
Novita
Novita AI calls itself the AI-native cloud for builders and agents: it sells model APIs, GPU cloud, dedicated endpoints and an Agent Sandbox.
The Novita Agent Sandbox gives each agent an isolated Linux runtime that starts from a template built from a Docker image, driven by Python, JavaScript SDKs or a CLI that follow the E2B interface. A sandbox can pause with its files and memory, resume in about a second, and wake on its own when traffic arrives. It is built for teams that run code interpreters, browser and computer-use agents, and short agent tasks, often alongside Novita's own model APIs.
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. “3rd cheapest of 367” means 2 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 | bochka: price rank | Novita: 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 long builds; Novita does not document Docker inside a sandbox and caps a session at 1 hour unless you turn on long-running mode. | 3rd cheapest of 367 $634 a month | 226th of 367, with limits $2,825 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month runs into Novita's session limits and 20 GB disk, while bochka can keep it running with its disk saved every minute. | 5th cheapest of 366 $657 a month | 43rd of 366, with limits $3,661 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Novita is built for this: short code runs that start fast, pause with their memory and come back on the next request. | 186th of 345, with limits $2,000 a month | 20th cheapest of 345 $191 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month 300 sandboxes at once is more than Novita's paid tier allows (100), so it needs an Enterprise contract there. | Cheapest of 361 $209 a month | 121st of 361, with limits $1,203 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 95th of 360, with limits $5,800 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 148th of 364, with limits $933 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that run Docker builds or Android emulators need Docker and /dev/kvm, which every bochka machine has and Novita does not document. | 4th cheapest of 377 $86 a month | 313th of 377, with limits $899 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that runs all month needs no session cap, more than 20 GB of disk and raw TCP; bochka has all three. | 18th cheapest of 368 $26 a month | 125th of 368, with limits $146 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both fit: Novita has a desktop sandbox with a VNC stream, and bochka streams a 60fps desktop with Chromium you can embed in your app. | 6th cheapest of 369 $200 a month | 18th cheapest of 369 $840 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 7th cheapest of 367 $200 a month | 81st of 367, with limits $420 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 6th cheapest of 346 $90 a month | 26th cheapest of 346 $284 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 71st of 338, with limits $1,800 a month | 168th of 338, with limits $5,686 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 28th of 360, with limits $277 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Novita fits, through its separate GPU instance product; the Agent Sandbox itself and bochka are CPU only. | Can't run it | 40th of 98, with limits $826 a month |
| 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 |
Key features
Every feature Battleships tracks (43)
| Feature | bochka | Novita |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Yes |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | No |
| Memory fork | No | Yes |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | No |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | Not published |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
Both were measured in the same StarSling hpc-sandbox-benchmarks run of 2026-09-29, on the Node.js build-and-test loop at 4 vCPU / 8 GB. bochka did 26.69 runs per second and Novita did 19.52, so bochka finished about 37% more CPU work in the same time. This measures CPU speed only, not start time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite.
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 | bochka, a month | Novita, 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 | $20 · $20/mo | $37 · Paid (pay-as-you-go) |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $153 · Paid (pay-as-you-go) · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $1,848 · Paid (pay-as-you-go) · with limits |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $525 · Paid (pay-as-you-go) · with limits |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $1,160 · Paid (pay-as-you-go) · with limits |
bochka: Plans start at $20 a month, and the whole fee becomes usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Novita: Novita bills per second for the vCPU and RAM you allocate while a sandbox runs, idle time included, from a prepaid balance with no monthly fee. A paused sandbox costs no compute; its saved state counts toward 60 GB of free storage per account, then is billed by the GB-hour. Egress prices are not published, and if the balance runs out, running sandboxes are terminated.
Limits in those scenarios
Novita's paid tier allows 100 sandboxes at once, so 300 sandboxes for your users and 1,000 short jobs at once do not fit without an Enterprise contract. Its sessions are capped (1 hour without long-running mode, and 3 or 24 hours on Paid depending on the page), which is why the always-on agent does not fit, and each sandbox has 20 GB of local disk. The 50-agent fleet does not fit because Docker inside a sandbox is not documented. bochka has no session cap, but at 1,000 short jobs at once even the $2,000 plan queues starts.
| Scenario | bochka | Novita |
|---|---|---|
| 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 Novita when
you run many short jobs that pause between requests and wake on traffic, need outbound rules, or must run in the US next to Novita's model APIs and GPUs.
- Memory pause and wake on request. Useful for short jobs that sleep between requests: a paused sandbox keeps its memory, costs no compute and wakes on new activity.
- Outbound rules. Novita can cut a sandbox off from the internet, or limit it to chosen IPs, ranges and domains.
- US regions, model APIs and GPUs in one account. Teams in the US who already use Novita's model APIs or GPUs can keep sandboxes on the same account and bill.
Use bochka when
your agents do real work for hours: Docker, builds, tests, emulators and a browser, on a faster full VM that never cuts them off.
- A full VM with Docker and /dev/kvm. Agents that run docker compose, build images, or start an Android emulator need these inside their machine. On Novita that work has no documented path, so you would test it yourself or move it elsewhere.
- Runs as long as the work takes. An agent that forgets to extend its timeout loses its work when Novita kills the sandbox. Long-running mode and pause avoid that, but your code has to set them on every sandbox.
- More CPU work in the same time. Agents spend much of their time waiting on installs, builds and tests. On Novita each of those waits is about a third longer, and since it bills per second while running, you pay for the waiting.
Questions people ask
Is bochka cheaper than Novita?
In most scenarios we priced, yes: one coding agent on workdays comes to $20 a month on bochka and $37 on Novita, and 50 agents in parallel come to $317 versus $1,848. For 1,000 short jobs at once Novita comes to $1,160 against $2,000 on bochka, though neither fits without higher limits.
Is bochka faster than Novita?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Novita did 19.52. That is about 37% more CPU work in the same time.
How long can a Novita sandbox run?
By default it times out after 5 minutes and is killed. Without long-running mode it lives at most 1 hour; Novita's quota table lists 3 hours on Paid while its sandbox page says 24 hours. bochka has no session cap on paid plans.
Can I run Docker inside a Novita sandbox?
Novita's docs use Docker images to build templates, but do not cover running Docker or /dev/kvm inside a sandbox. On bochka every machine has Docker, root, systemd and /dev/kvm.
Can bochka pause a sandbox with its memory like Novita?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but resuming boots the machine again. Novita can pause with memory and resume running processes in about a second.
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.
Start a sandbox
Install the CLI, then run bochka new.
Product preview