bochka vs AWS Fargate
Fargate runs your containers on AWS without servers to manage, and it is built for services and batch jobs. bochka gives each agent a whole Linux machine that can run Docker, keeps its disk and comes with coding agents ready to drive.
Where bochka stands out
A whole machine, not a locked-down container
A bochka sandbox is a full VM with root, Docker, systemd, SSH and /dev/kvm. Fargate runs your container without privileged mode, so Docker in Docker does not work, host devices are blocked, and the only extra Linux capability you can add is CAP_SYS_PTRACE.
The disk stays, with snapshots and fork
bochka saves the whole disk every minute and when a sandbox stops, a stopped sandbox costs nothing, and you can fork a running sandbox with its disk. On Fargate the built-in 20 GiB storage is erased when the task stops.
Built for agents, not services
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them from outside through one API. Real API keys stay outside the sandbox in a credentials proxy, and each sandbox gets HTTPS URLs on up to 50 ports with no load balancer to set up.
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
AWS Fargate
AWS Fargate is Amazon's serverless compute engine for containers: you hand ECS or EKS a container image and AWS runs it without servers for you to manage.
Fargate is not a sandbox product. It is a hyperscaler service for running container workloads: you write a task definition with an image, CPU, memory, networking and IAM, and each task gets its own isolated environment that does not share a kernel with other tasks. It is built for teams that run web services, workers and batch jobs inside AWS, and it overlaps with bochka where you want each agent or user to get its own isolated machine.
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 | AWS Fargate: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent that runs docker compose or builds images cannot do it on Fargate, which blocks privileged containers; bochka runs Docker inside every sandbox. | 3rd cheapest of 367 $634 a month | 77th of 367, with limits $644 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs its files to survive restarts; Fargate erases the task's disk on stop unless you attach EBS or EFS, while bochka keeps the whole disk. | 5th cheapest of 366 $657 a month | 112th of 366, with limits $636 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Fargate can start many small containers per second and bills per second with a 1-minute minimum, which suits short code runs if you build the API around it. | 186th of 345, with limits $2,000 a month | 77th of 345, with limits $97 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month To give each user an HTTPS preview on Fargate you set up a load balancer or API gateway; bochka gives every sandbox HTTPS URLs on up to 50 ports. | Cheapest of 361 $209 a month | 78th of 361, with limits $698 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Fargate Spot and its high launch rate suit large batches of short rollouts that can survive a two-minute interruption notice. | 34th of 360, with limits $2,000 a month | 15th of 360, with limits $872 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 | 4th cheapest of 364 $174 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build container images or Android apps need Docker or /dev/kvm, and Fargate allows neither; bochka has both. | 4th cheapest of 377 $86 a month | 26th cheapest of 377 $296 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and a disk that keeps installed packages; Fargate offers ECS Exec instead of SSH and wipes its built-in storage on stop. | 18th cheapest of 368 $26 a month | 215th of 368, with limits $28 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Fargate runs headless containers with no desktop; bochka streams a full Linux desktop at 60fps with Chromium for computer-use agents. | 6th cheapest of 369 $200 a month | 101st of 369, with limits $192 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 | 167th of 367, with limits $105 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 | 168th of 346, with limits $80 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 | 49th of 338, with limits $1,313 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 | 107th of 360, with limits $45 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 |
| 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
| Feature | bochka | AWS Fargate |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Each task in its own isolated environment that shares no kernel with other tasks |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | Up to 32 vCPU / 244 GB per Linux task |
| Docker, systemd and root | Root, Docker and systemd inside every sandbox | Root inside a container; no privileged mode, so no Docker in Docker; only CAP_SYS_PTRACE can be added |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | No; the devices parameter is not supported and host devices are blocked |
| Shell access | SSH into any sandbox | No SSH; ECS Exec opens a shell or runs commands in a container |
| What survives a stop | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing | The built-in 20 GiB storage is erased; data survives only on an EBS volume you keep or an EFS mount |
| Snapshots and fork | Automatic snapshots every minute; fork a running sandbox with its disk | EBS snapshots can seed volumes for new tasks; no fork of a running task |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP | A public IP on the task's network interface, or a load balancer you set up for HTTPS, TCP or UDP |
| Network controls | Open internet, no provider-side allowlist | Security groups and network ACLs on every task, inside your own VPC |
| Coding agents | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API | None; you bring your own container image and agent |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Secrets Manager or Parameter Store values injected into the container as environment variables |
| Desktop and browser | Full Linux desktop streamed at 60fps, with Chromium and computer use | Headless containers only |
| Operating systems | Linux on x86_64 | Linux on x86_64 or ARM64, and Windows Server containers |
| Regions | EU only (Germany, Finland, France) | Most commercial AWS regions worldwide, plus GovCloud |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | bochka | AWS Fargate |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | No |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | No |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | No |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Yes |
| Public IPv4 | No | Yes |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | Yes |
| Arm64 | No | Yes |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: Fargate was not part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on its Node.js build-and-test loop at 4 vCPU / 8 GB. AWS does not let you pick the processor model behind a Fargate task, so a fair comparison would need its own run.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. AWS Fargate 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 | bochka, a month | AWS Fargate, 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 | $21 · Pay-as-you-go |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $65 · 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,023 · 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 | $309 · Pay-as-you-go |
| 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 | $581 · Pay-as-you-go |
bochka: 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.
AWS Fargate: Fargate bills per second for the vCPU, memory and extra storage a task asks for, from the start of the image pull until the task ends, with a 1-minute minimum on Linux. Savings Plans cut the rate in exchange for a 1- or 3-year spend commitment, Spot is cheaper but can be interrupted, and public IPv4 addresses, load balancers, NAT gateways and data transfer are billed separately by AWS.
Limits in those scenarios
The always-on agent only reaches the price in the table with a 3-year Savings Plan commitment, which is why it does not fit cleanly. The agent fleet does not fit because Fargate cannot run Docker inside a task. New AWS accounts start with a quota of 6 Fargate vCPUs per region that grows with use or on request, so a fleet of 4 vCPU agents needs a raise first. bochka's start limits are lower for bursts: at 1,000 short jobs at once, the $2000 plan queues starts above 90 per minute, while Fargate launches them within its default rates.
| Scenario | bochka | AWS Fargate |
|---|---|---|
| One coding agent, workdays | None that bite | 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 | None that bite |
| 1,000 short jobs at once |
| None that bite |
Which one should you use?
Use AWS Fargate when
your workload is a container service or batch job that must stay inside your AWS account, needs Windows, ARM or very large tasks, or launches thousands of short interruption-tolerant jobs.
- It lives inside your AWS account. Teams already on AWS keep every task inside their own VPC, IAM and security groups, in most regions worldwide.
- Bigger tasks, Windows and ARM. Workloads that need up to 32 vCPU / 244 GB, Windows Server containers or ARM64 Graviton can run on Fargate.
- Fast launches and Spot capacity. Large batches of short, interruption-tolerant jobs can launch quickly and run on Spot capacity at a deep discount.
Use bochka when
your agents do real work on a machine for hours: Docker, builds, tests, emulators and a browser, with a disk that keeps everything, URLs you can open and agents you drive from outside.
- A whole machine, not a locked-down container. Coding agents reach for docker build, docker compose and Android emulators all the time. On Fargate those commands fail, and the workaround is running ECS on your own EC2 instances, which brings back the servers you wanted to avoid.
- The disk stays, with snapshots and fork. Without it, every restart repeats the clone, the installs and the build. On Fargate you can keep data on an EBS volume or EFS mount, but you set those up and pay for them yourself, and there is still no fork.
- Built for agents, not services. On Fargate you build the harness, the preview routing and the key handling yourself, and secrets arrive as environment variables inside the container the agent controls, where one prompt injection can read them.
Questions people ask
Is bochka cheaper than AWS Fargate?
In most of the scenarios on this page, yes, though a single agent working a 9-to-5 day costs about the same on both. For 1,000 short jobs at once Fargate costs less in the table and launches them all, while bochka's plans queue the starts.
Can I run Docker inside AWS Fargate?
No. AWS says privileged containers are unavailable on Fargate, which affects use cases such as running Docker in Docker. bochka runs Docker inside every sandbox, along with systemd and /dev/kvm.
Do files survive when a Fargate task stops?
Not on the built-in storage: AWS erases the 20 GiB task volume when the workload stops. You can keep data on an EBS volume set not to delete on stop, or on an EFS mount. bochka keeps the whole disk and saves it every minute.
Can I SSH into a Fargate task?
Not with SSH. AWS offers ECS Exec to run commands or open a shell in a container, and nobody can connect to the host underneath. Every bochka sandbox accepts SSH.
Is Fargate a sandbox for AI agents?
Not by design. Fargate is a general container engine for services and batch jobs, so you bring the image, the agent, the networking and the key handling. bochka is built for agents: a full machine per agent with coding agents, a credentials proxy and preview URLs included.
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