Ona vs AWS AgentCore
Ona, formerly Gitpod, gives your engineers and its Codex agent full dev environments built from a Dev Container config, sold through sales. AWS AgentCore hosts your own agent code in 2 vCPU microVM sessions of up to 8 hours, with managed Code Interpreter and Browser tools, billed pay as you go inside your AWS account.
The companies and products
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.
AWS AgentCore
Amazon Bedrock AgentCore is a set of AWS services to deploy and run AI agents: a Runtime that hosts your agent code, plus built-in Code Interpreter and Browser tools.
AgentCore is not a sandbox product first. It is a hyperscaler's agent platform: you push a container image or code, and each Runtime session gets its own Firecracker microVM that you reach through AgentCore APIs. Around it sit managed tools (Code Interpreter, Browser) and services for memory, identity, gateways and evaluations, and an Instances compute type runs longer sessions on EC2 in your own account. It is built for teams who already build on AWS and want agents to stay inside their account, IAM and VPC.
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. “324th cheapest of 367” means 323 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 | Ona: price rank | AWS AgentCore: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Ona gives a coding agent a full dev environment but only through an Enterprise contract, and AgentCore caps a microVM session at 2 vCPU and 8 hours; bochka fits fully with a full VM, Docker and a disk that keeps everything. | 324th of 367, with limits $7,315 a month | 100th of 367, with limits $888 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant needs auto-stop set to Never on Ona, and the Instances type on EC2 in your account on AgentCore, because its microVM sessions end after 8 hours; on bochka it simply keeps running. | 83rd of 366, with limits $8,504 a month | 64th of 366, with limits $1,300 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 AgentCore Code Interpreter is built for this, billing only for CPU actually used, while Ona is a dev-environment platform with no code interpreter tool. | 335th of 345, with limits $5,320 a month | 7th cheapest of 345 $114 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 Ona is built for your own engineers and AgentCore sessions have no open ports, so neither lets your users open the app their sandbox runs; bochka gives each one HTTPS URLs on up to 50 ports. | 330th of 361, with limits $5,988 a month | 210th of 361, with limits $506 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 | 283rd of 360, with limits $9,773 a month | 125th of 360, with limits $8,075 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 | 334th of 364, with limits $5,768 a month | 33rd cheapest of 364 $650 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 Ona nor AgentCore can fork a warm machine or documents /dev/kvm, which Android and VM-image builds need; bochka has both. | 365th of 377, with limits $5,461 a month | 52nd cheapest of 377 $399 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, prebuilds and SSH, while AgentCore has no SSH and resets everything outside its storage mount after a stop. | 368th of 368, with limits $5,140 a month | 228th of 368, with limits $52 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 Ona environments have no graphical desktop and AgentCore Browser drives a browser, not a whole desktop; bochka streams a full Linux desktop at 60fps. | 353rd of 369, with limits $5,691 a month | 104th of 369, with limits $202 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 AgentCore Browser is a managed Chromium with live view and session replay, and bochka runs Chromium on a full machine you control; Ona has no browser tool for agents. | 150th of 367, with limits $5,346 a month | 4th cheapest of 367 $144 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 | 146th of 346, with limits $5,468 a month | 27th cheapest of 346 $287 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 | 261st of 338, with limits $14,360 a month | 165th of 338, with limits $5,458 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 | 93rd of 360, with limits $5,228 a month | 62nd of 360, with limits $294 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 | Ona | AWS AgentCore | bochka |
|---|---|---|---|
| What it is | A cloud dev-environment platform for engineers and its Codex agent | An AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser tools | A sandbox platform: each agent gets its own full Linux machine, driven from code |
| Isolation | An isolated VM per environment with dedicated compute, storage and networking | A Firecracker microVM per Runtime session; Code Interpreter and Browser in a containerized environment | A full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | EC2 or GCP classes in your own cloud, such as 4 vCPU / 16 GB | 2 vCPU / 8 GB per microVM session, not adjustable; bigger EC2 types only on Instances | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No hard cap; stops after 30 idle minutes by default, and background work does not count as activity; can be set to Never | Up to 8 hours per microVM lifecycle, 15 idle minutes by default; up to 14 days on Instances | No session cap on paid plans; you set the time to live |
| Files after a stop | The disk persists, but its storage stays on your cloud bill; Core archives a stopped environment after 3 days | Only one storage mount under /mnt, up to 1 GB, in preview; EBS volumes on Instances; the rest resets | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | No copy of an environment; you can create a project from its config | No snapshot or fork of a session | Fork a running sandbox into copies with its disk |
| Starting point | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Your arm64 container image or code, or AWS-managed images for Code Interpreter | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Docker and /dev/kvm | Docker and root inside the Dev Container; nested virtualization not documented | Root inside the microVM; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm on every machine |
| Browser and desktop | Browser IDE, VS Code and JetBrains; no graphical desktop | Managed Chromium with live view, session recording and replay, profiles and proxies; no full desktop | Full Linux desktop streamed at 60fps, with Chromium and computer use |
| Reaching the sandbox | HTTPS URL per port and SSH; no raw TCP or public IP documented | No open ports or SSH; reached only through AgentCore APIs with IAM or JWT | HTTPS URLs for up to 50 ports, token-protected; raw TCP; SSH |
| Coding agents | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | AWS's managed harness built on Strands Agents, or your own agent code | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets injected as environment variables or files | AgentCore Identity stores OAuth tokens and API keys and hands them to your agent code | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Where it runs | Enterprise runners in your own AWS or GCP account; Ona Cloud in Frankfurt and North Virginia for existing Core subscribers | 17 commercial AWS regions plus GovCloud, with VPC mode, security groups and PrivateLink | EU only: Germany, Finland, France |
| GPUs | GPU classes on Enterprise runners, such as one NVIDIA A10G with 16 vCPU and 64 GB | NVIDIA G-series and Inferentia2 on the Instances type | None |
Every feature Battleships tracks (43)
| Feature | Ona | AWS AgentCore | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | No | No | 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 | Yes | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | No | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Ona or AWS AgentCore: neither was in the public benchmark runs we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29, on dedicated AMD Ryzen 9 9950X hosts. An AgentCore microVM session stops at 2 vCPU, so a like-for-like test would need its Instances type.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Ona and AWS AgentCore 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 | Ona, a month | AWS AgentCore, 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,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $26 · Pay-as-you-go (Instances) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $5,140 · Enterprise (AWS Marketplace 12-month contract) · with limits | $107 · Pay-as-you-go (Instances) · 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 | $6,521 · Enterprise (AWS Marketplace 12-month contract) · with limits | $1,286 · Pay-as-you-go (Instances) · 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 | $5,432 · Enterprise (AWS Marketplace 12-month contract) · with limits | $423 · Pay-as-you-go · 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 | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $1,615 · Pay-as-you-go (Instances) | $2,000 · $2000/mo · with limits |
Ona: New Core subscriptions are closed, so the Ona prices here use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract (about $5,000 a month), with compute on your own cloud bill. Real Enterprise prices are negotiated with sales.
AWS AgentCore: Runtime microVMs, Code Interpreter and Browser bill per second for CPU actually used and for memory, with no monthly fee. The 4 vCPU shape in these scenarios is the Instances type: the EC2 on-demand price plus a 12% management fee, with EBS and data transfer on top.
AWS AgentCore: 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
No Ona scenario fits as published, because a new customer can only buy Enterprise through sales, and the table assumes 3 environments at once since no Enterprise limit is published. AgentCore fits only the 1,000 short jobs scenario: a 4 vCPU agent needs the Instances type, and files outside the storage mount reset after each stop, so installed packages must be set up again. bochka fits every scenario except that burst, where its plan queues starts above 90 per minute.
| Scenario | Ona | AWS AgentCore | 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 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. Useful if your engineers work in the same environments as their agents, with browser, VS Code and JetBrains IDEs and prebuilds.
- Long sessions on bigger machines. Useful if an agent works for hours on one machine: Ona has no hard session cap and runs larger VM classes than 2 vCPU.
- A managed Codex agent. Useful if you want Codex to plan, code, test and open pull requests, started from chat, Linear or an automation.
Use AWS AgentCore when
your agents must stay inside your AWS account and VPC, or are short code and browser tasks that fit its managed tools.
- It lives inside your AWS account. Teams built on AWS keep agents behind their own IAM, VPC and PrivateLink, in 17 commercial regions, with no contract to sign.
- Managed tools that bill for what they use. For short code runs and browser tasks, Code Interpreter and Browser charge only for CPU actually used, with live view and replay.
- GPUs and two-week sessions on Instances. Agents that need a GPU or a session of up to 14 days can run on EC2 in your account.
Where bochka fits
Ona is built for engineers in an IDE and AgentCore for agent code that lives in AWS. If your own code starts and drives the agents, and each one needs a whole machine for hours with Docker, a desktop and a link you can open, bochka gives you that on a self-serve plan.
A whole machine that keeps its work
AgentCore keeps only a 1 GB mount after a stop, so installed packages vanish. Ona keeps the disk but bills it while stopped, or archives it after 3 days on Core. bochka saves the whole disk every minute and a stopped sandbox is free.
Docker, /dev/kvm, a desktop and fork
Neither documents /dev/kvm, so Android emulators and microVMs are out, neither has a full desktop for computer use, and neither can copy a warm machine. bochka has all of these, and forks a running sandbox with its disk.
Open ports and agents you drive from outside
AgentCore has no open ports, so you proxy previews through your own code, and Ona's SDK needs an Enterprise contract. bochka gives HTTPS on 50 ports and raw TCP, and drives Claude Code, Codex and others inside from outside through one API.
Use bochka when your code starts and drives the agents: full VMs with Docker, /dev/kvm, a desktop and open ports, no session cap on paid plans, and disks that keep their work and fork while running. Compare it one to one: bochka vs Ona and bochka vs AWS AgentCore.
Questions people ask
Is Ona cheaper than AWS AgentCore?
No. In every scenario we priced, AgentCore costs less: one agent running all month is $107 on AWS AgentCore against $5,140 on Ona, and 50 agents in parallel are $1,286 against $6,521. Ona's figure uses its Enterprise listing on AWS Marketplace, and the real price is a sales quote.
Which is faster, Ona or AWS AgentCore?
We have no comparable measurement for either: neither was in the public benchmark runs we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.
Can Ona or AgentCore run Docker?
Ona runs Docker with root inside the Dev Container, but does not document nested virtualization. AgentCore runs your arm64 container image as root in a microVM, and its docs do not say Docker or /dev/kvm work inside a session. bochka runs Docker and exposes /dev/kvm on every machine.
How long can a session run on Ona and AgentCore?
Ona has no hard cap, but stops an environment after 30 idle minutes by default unless auto-stop is set to Never. An AgentCore microVM session lasts up to 8 hours, or up to 14 days on the Instances type. bochka has no session cap on paid plans.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025, and Ona is now part of OpenAI. New Core subscriptions are no longer available, so new customers go through sales.
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.
Try bochka
Install the CLI, then run bochka new.
Product preview