E2B vs Ona
E2B is a sandbox API: your code starts a small Firecracker microVM per agent job, and it can pause with its memory and wake on the next request. Ona, formerly Gitpod and now part of OpenAI, is a cloud dev environment platform for engineers and its Codex Agent, sold to new customers through sales.
The companies and products
E2B
E2B calls itself the AI agent cloud: an API that gives each agent session its own isolated Linux machine.
Every E2B sandbox is a Firecracker microVM that boots from a snapshot, so it starts fast and can be paused and resumed with its memory. You build custom sandboxes from templates based on a Docker image, and drive them from Python or JavaScript SDKs. It is built for teams that run many short code, data or agent jobs, and its runtime is open source.
- Isolation
- Firecracker microVM per sandbox
- Bring your own cloud
- Enterprise data plane in your AWS, GCP or Azure account
- Compliance
- SOC 2 Type II; HIPAA BAA on request
- Machine size
- 1 to 8 vCPU and 1 to 8 GiB RAM, CPU only
Ona
Ona, formerly Gitpod, is a platform for cloud dev environments and background coding agents, and is now part of OpenAI.
Ona is a different kind of product from bochka: a dev-environment platform, not a sandbox API. Each task or developer gets an isolated VM built from a Dev Container config, which people open in a browser IDE, VS Code or JetBrains, and where Ona's Codex Agent can plan, code, test and open pull requests. It is built for engineering teams who want the same governed environment for every developer and agent; new customers run it in their own AWS or GCP account on an Enterprise contract.
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. “16th cheapest of 367” means 15 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 | E2B: price rank | Ona: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month E2B fits a software factory through its API, while Ona needs the Enterprise SDK to start environments from code; bochka adds no session cap and /dev/kvm. | 16th cheapest of 367 $4,143 a month | 324th of 367, with limits $7,315 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that runs all month hits E2B's 24-hour session cap, and on Ona it needs auto-stop set to Never; bochka simply keeps running. | 51st of 366, with limits $5,348 a month | 83rd of 366, with limits $8,504 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 E2B is built for short code runs that start fast and pause with their memory, which Ona, a dev environment platform, is not. | 37th cheapest of 345 $421 a month | 335th of 345, with limits $5,320 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 E2B hands sandboxes to your users through an API, while Ona is built for your own engineers and defaults to 10 running environments per user. | 23rd cheapest of 361 $2,354 a month | 330th of 361, with limits $5,988 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 E2B's memory forks and high start rate suit many short rollouts; Ona has no way to copy an environment. | 2nd cheapest of 360 $9,384 a month | 283rd of 360, with limits $9,773 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 | 78th cheapest of 364 $1,975 a month | 334th of 364, with limits $5,768 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 Neither is a great CI fit: E2B has no nested virtualization and Ona starts each run from a prebuild, while bochka has /dev/kvm and forks warm machines. | 337th of 377, with limits $1,429 a month | 365th of 377, with limits $5,461 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is a full cloud IDE with Dev Containers and prebuilds, while E2B caps a session at 24 hours; bochka is a full VM you keep all month. | 192nd of 368, with limits $358 a month | 368th of 368, with limits $5,140 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 E2B has a Linux desktop for computer use and Ona has no graphical desktop; bochka streams a 60fps desktop with Chromium. | 32nd cheapest of 369 $1,342 a month | 353rd of 369, with limits $5,691 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 | 100th of 367, with limits $746 a month | 150th of 367, with limits $5,346 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 | 57th cheapest of 346 $554 a month | 146th of 346, with limits $5,468 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 | 227th of 338, with limits $9,223 a month | 261st of 338, with limits $14,360 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 | 11th cheapest of 360 $1,043 a month | 93rd of 360, with limits $5,228 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 | E2B | Ona | bochka |
|---|---|---|---|
| What it is | A sandbox API that gives each agent session its own Linux machine | A cloud dev environment platform for engineers and its Codex Agent | A sandbox API with full VMs and coding agents built in |
| Isolation | Firecracker microVM with its own kernel | Isolated VM with dedicated compute, built from a Dev Container config | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Signing up and driving it from code | Self-serve Hobby and Pro plans; Python and JavaScript SDKs | New Core subscriptions are closed; Enterprise through sales, with the SDK on Enterprise only | Self-serve plans from a free trial up; API and SDK on every plan |
| CPU benchmark (4 vCPU / 8 GB) | 12.61 runs/s | Not measured | 26.69 runs/s |
| Docker and nested virtualization | Docker inside; nested virtualization not supported | Docker and root inside the Dev Container; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Session length | Up to 1 hour on Hobby, 24 hours on Pro; pausing resets the clock | No hard cap, but stops after 30 idle minutes by default; background work does not count; can be set to Never | No cap on paid plans; you set the time to live |
| Pause and resume | Saves memory and disk; resumes in about a second with processes running, and can wake on the next request | Disk persists across stops; Core archives a stopped environment after 3 days | Disk saved every minute and on stop; a stopped sandbox costs nothing; resume boots the machine again |
| Fork | Fork a running sandbox with its memory, up to 20 copies per call | No environment copy; you can create a project from an environment's config | Fork a running sandbox with its disk |
| Desktop and computer use | Linux desktop for computer use | Browser IDE plus VS Code and JetBrains; no graphical desktop | 60fps desktop with Chromium, computer use and an embeddable stream |
| Team IDE | None; you drive it from code | Browser, VS Code and JetBrains IDEs with Dev Containers and prebuilds | None; you reach it over SSH, HTTPS or the desktop |
| Reaching the sandbox | HTTPS URL per port, public by default unless you turn on a token; no dedicated IP | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Coding agents | Templates and guides for many agents, run through the command API | Codex Agent started from chat, a Linear issue or an automation | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets injected into outbound HTTPS headers (private beta) | Secrets injected as environment variables or files | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs, regions and your own cloud | CPU only; US, EU and APAC; open-source runtime and bring your own cloud on Enterprise | GPU types such as an A10G; Enterprise runners in your own AWS or GCP account | No GPUs; EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | E2B | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | 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 | 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 | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | Yes | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | No | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On StarSling's hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, in the same run, bochka did 26.69 runs per second and E2B did 12.61, so bochka finished about twice as much CPU work. Ona was not in the benchmark runs, so there is no comparable measurement for it. 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. Ona 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 | E2B, a month | Ona, 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 | $202 · Pro | $5,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $368 · Pro · with limits | $5,140 · Enterprise (AWS Marketplace 12-month contract) · 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,773 · Pro | $6,521 · Enterprise (AWS Marketplace 12-month contract) · 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 | $1,395 · Pro+ (600 concurrent) | $5,432 · Enterprise (AWS Marketplace 12-month contract) · 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 | $2,797 · Pro++ (1,100 concurrent) | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
E2B: E2B bills per second for the vCPU and RAM you set, idle time included, until you pause or kill the sandbox. Pro costs $150 a month for higher limits, with no usage credit, and more concurrency costs $500 a month per 500 slots.
Ona: New Core subscriptions are closed, so Ona prices here use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract, plus compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Ona: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
E2B caps a session at 24 hours on Pro, which is why it does not fit the always-on scenario, and its Pro disk is 20 GiB. No Ona scenario fits as published, because new customers can only buy Enterprise through sales, and the table assumes 3 environments at once since Ona publishes no Enterprise limit. For 1,000 short jobs at once, E2B Pro++ only queues bursts above 300 starts a minute, while bochka's $2,000 plan caps starts per hour and per day.
| Scenario | E2B | Ona | 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 E2B when
your code runs many short agent or code jobs that pause between requests, branch from the same memory, or must run in the US or APAC.
- Memory pause and wake on request. For short jobs that sleep between requests, a paused E2B sandbox comes back in about a second with its processes running.
- A self-serve sandbox API. If your code starts the machines, E2B has self-serve plans and SDKs, while Ona's SDK needs an Enterprise contract.
- Huge bursts of short jobs. For thousands of short jobs at once, E2B Pro++ allows 1,100 sandboxes at a time and memory forks for rollouts.
Use Ona when
your engineers want a governed cloud IDE shared with a Codex agent, inside your own AWS or GCP account or with a GPU.
- A full cloud IDE for your team. If engineers work in the same environments as their agents, Ona has browser, VS Code and JetBrains IDEs with prebuilds.
- Runs in your own cloud. If environments must run inside your own AWS or GCP account, Ona's Enterprise runners do that by default.
- GPU environments. If your agents need a GPU, Ona's Enterprise runners can use GPU types, such as an A10G VM with 16 vCPU and 64 GB.
Where bochka fits
If your code starts agents that work for hours, look at bochka. E2B's sessions stop at 24 hours and Ona is a team IDE sold through sales, while bochka gives each agent a full, fast VM with an API on every plan. bochka is not the pick for GPUs, for runs outside the EU, or for memory pause.
A full machine that keeps running
On E2B a long task stops at 24 hours and your code must pause and resume it. On Ona an agent stops after 30 idle minutes unless auto-stop is set to Never. bochka has no session cap on paid plans.
Nested virtualization, a desktop and open ports
Android emulators need /dev/kvm, which E2B does not support and Ona does not document. Ona has no graphical desktop and neither offers raw TCP. bochka has /dev/kvm, a 60fps desktop and HTTPS on 50 ports.
Faster CPUs and agents built in
bochka did 26.69 runs per second against E2B's 12.61, so builds wait about half as long. Claude Code, Codex and more come preinstalled, and real API keys stay outside in a credentials proxy.
Use bochka when your agents do real work for hours: builds, Docker, emulators and a browser on a fast full VM that never cuts them off, driven by an API on every plan. Compare it one to one: bochka vs E2B and bochka vs Ona.
Questions people ask
Is E2B cheaper than Ona?
In the scenarios we priced, yes: one coding agent on workdays is $202 a month on E2B and $5,030 on Ona, and 50 agents in parallel are $2,773 against $6,521. Ona's numbers use its Enterprise listing, since new Core plans are closed, and real quotes come from sales. bochka is $20 and $317 for the same two.
Which is faster, E2B or Ona?
Ona has no comparable CPU measurement. E2B did 12.61 runs per second on the hpc-sandbox-benchmarks test at 4 vCPU / 8 GB, and bochka did 26.69 in the same run.
Can E2B and Ona run Docker?
Both run Docker inside the sandbox. E2B's docs say nested virtualization is not supported, and Ona does not document it on its VM classes. bochka exposes /dev/kvm for Android emulators and VMs.
Can an E2B or Ona sandbox run for days?
Not in one E2B session: it stops after 24 hours on Pro, though pausing resets the clock. Ona has no hard cap but stops after 30 idle minutes by default unless auto-stop is set to Never. bochka has no session cap on paid plans.
Can I still sign up for Ona?
Not self-serve. Ona's billing docs say new Core subscriptions are no longer available, so new customers go through sales for Enterprise. E2B and bochka both have self-serve plans.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025, and Ona is now part of OpenAI. Its managed agent is Codex.
Try bochka
Install the CLI, then run bochka new.
Product preview