bochka vs AWS Lambda
Lambda runs your code in short bursts: functions stop after 15 minutes, and its newer MicroVMs stop after 8 hours. bochka gives each agent a whole Linux machine with Docker and a disk that stays, for as long as the work takes.
Where bochka stands out
A whole machine with no clock running out
A bochka sandbox has no session cap on paid plans, so an agent can work for days on one machine. A Lambda function stops after 15 minutes, and a Lambda MicroVM is terminated after 8 hours, counting the time it spends suspended.
Root, Docker, systemd and /dev/kvm
Every bochka sandbox is a full VM with root, Docker, systemd, SSH and /dev/kvm. Lambda functions run as a least-privileged user on a read-only file system, and MicroVMs run your app as one container, with no /dev/kvm documented for either.
A disk that stays, plus agents and keys built in
bochka saves the whole disk every minute and on stop, keeps it for free while stopped, and can fork a running sandbox. Claude Code, Codex and five more agents come preinstalled with a prompt, steer and events API, and real API keys stay outside the sandbox in a credentials proxy.
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 Lambda
AWS Lambda is Amazon's serverless compute service: you hand it code or an image, and AWS runs it on demand without servers for you to manage.
Lambda started as a function service, not a sandbox: each request runs in a Firecracker microVM for up to 15 minutes as an unprivileged user, and Lambda is designed for tasks that do not keep state between calls. AWS has since added Lambda MicroVMs, a separate API for sandboxes and dev environments: you build an image from a Dockerfile, run one MicroVM per user or job, reach it through an HTTPS endpoint, and it can suspend with its memory and resume, for up to 8 hours in total. It is built for teams that run event-driven code inside AWS, and it overlaps with bochka where each agent or user needs 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 Lambda: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent works for hours and runs docker build; a Lambda function stops at 15 minutes and a MicroVM at 8 hours, while bochka runs Docker with no time cap. | 3rd cheapest of 367 $634 a month | 183rd of 367, with limits $2,048 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month cannot fit in a Lambda MicroVM's 8-hour lifespan; bochka keeps one machine and its disk for as long as you pay for it. | 5th cheapest of 366 $657 a month | 279th of 366, with limits $5,309 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs are what Lambda does best: functions start on each request and bill by the millisecond, and MicroVMs suspend with their memory between calls. | 186th of 345, with limits $2,000 a month | 140th of 345, with limits $309 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Lambda MicroVMs give each user an HTTPS endpoint that wakes a suspended machine on the next request, but end it after 8 hours; bochka machines keep their disk across days. | Cheapest of 361 $209 a month | 169th of 361, with limits $2,708 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Lambda can create up to 1,000 function environments every 10 seconds, which suits huge batches of short, stateless rollouts. | 34th of 360, with limits $2,000 a month | 136th of 360, with limits $8,340 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 | 133rd of 364, with limits $669 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, which Lambda functions do not allow; bochka has both. | 4th cheapest of 377 $86 a month | 292nd of 377, with limits $569 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs to stay up for weeks with SSH and a disk that keeps packages; a Lambda MicroVM is terminated after 8 hours at most. | 18th cheapest of 368 $26 a month | 131st of 368, with limits $311 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Lambda has no desktop or managed browser; bochka streams a full Linux desktop at 60fps with Chromium for computer-use agents. | 6th cheapest of 369 $200 a month | 191st of 369, with limits $619 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 | 269th of 367, with limits $615 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 | 280th of 346, with limits $500 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 | 232nd of 338, with limits $9,843 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 | 257th of 360, with limits $394 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
Every feature Battleships tracks (43)
| Feature | bochka | AWS Lambda |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | No |
| Systemd | Yes | No |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | No |
| Persistent disk | Yes | No |
| 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 | No |
| 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 | 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 | No |
| Arm64 | No | Yes |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| 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: Lambda 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. Lambda gives CPU in proportion to memory and does not let you pick the processor, 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 Lambda 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 Lambda, 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 | $20 · Pay-as-you-go · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $107 · 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,331 · 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 | $767 · 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 | $1,662 · 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 Lambda: Functions bill per millisecond for the memory you set, plus a fee per request, with a monthly free tier. Lambda Managed Instances, which the scenario table uses for 4 vCPU / 8 GiB on c7g.xlarge, bill the EC2 instance price plus a 15% management fee. MicroVMs, which the table does not model, bill per second for baseline vCPU and memory while running, extra for bursts above baseline, snapshot storage while suspended, and a small fee to save or load state on each suspend, resume and launch.
Limits in those scenarios
The workday agent, the always-on agent and the agent fleet do not fit on Lambda because a function call stops after 15 minutes and keeps no disk between runs; the fleet also needs Docker, which functions do not allow. A Lambda MicroVM would lift the cap to 8 hours, enough for one workday session but not for an agent that stays up all month. New AWS accounts start with reduced Lambda concurrency and memory quotas that grow with use. bochka's start limits are lower for bursts: at 1,000 short jobs at once, the $2,000 plan queues starts above 90 per minute, while Lambda starts them all.
| Scenario | bochka | AWS Lambda |
|---|---|---|
| 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 | None that bite |
| 1,000 short jobs at once |
| None that bite |
Which one should you use?
Use AWS Lambda when
your work is event-driven code or large bursts of short, stateless jobs that must stay inside your AWS account, or interactive sessions under 8 hours that should sleep with their memory between requests.
- Suspend with memory and wake on request. Interactive sessions that sit idle can suspend with memory and disk and resume when the next request arrives.
- It lives inside your AWS account. Teams already on AWS keep IAM roles, VPC egress rules and the rest of their stack in one account, in most regions worldwide.
- Huge bursts of short work. Event-driven code and large batches of short, stateless jobs scale fast and bill by the millisecond.
Use bochka when
your agents do real work on one machine for hours or days: 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 with no clock running out. Agent tasks often take longer than an hour and need their state at the end. On Lambda you split the work into pieces that save and reload their state, or you rebuild it in a fresh MicroVM every 8 hours.
- Root, Docker, systemd and /dev/kvm. Coding agents reach for docker build, docker compose, apt and Android emulators all the time. On a Lambda function those fail, and a MicroVM documents neither Docker inside nor /dev/kvm, so builds and emulators need another machine.
- A disk that stays, plus agents and keys built in. On Lambda the disk is temporary, so each new machine repeats the clone and the installs, and secrets are read into the machine the agent controls, where one prompt injection can leak them.
Questions people ask
Is bochka cheaper than AWS Lambda?
For agents that stay up, yes: the always-on agent costs $26 a month on bochka and $107 a month on Lambda, and Lambda does not fit it anyway because of the 15-minute cap. For 1,000 short jobs at once Lambda costs $1,662 a month and starts them all, while bochka's $2,000 plan queues the starts, so Lambda fits that one better.
Can an AI agent run for hours on AWS Lambda?
Not in a function: one call stops after 15 minutes. Lambda MicroVMs can run for up to 8 hours in total, including time spent suspended, and then Lambda terminates them. bochka has no session cap on paid plans.
What are Lambda MicroVMs?
A newer part of Lambda for sandboxes and dev environments. You build an image from a Dockerfile, run one MicroVM per user or job on ARM64, reach it through a token-protected HTTPS endpoint, and it can suspend with its memory and resume on the next request, for up to 8 hours.
Can I run Docker inside AWS Lambda?
Not in a function: code runs as a least-privileged user on a read-only file system, and a container image is only how you package it. MicroVMs run your app as a container built from your Dockerfile. bochka runs Docker inside every sandbox, along with systemd and /dev/kvm.
Do files survive on AWS Lambda?
A function's /tmp is temporary and tied to one execution environment, and a MicroVM keeps its disk only until its 8-hour lifespan ends. For lasting files you mount EFS or S3 Files. bochka keeps the whole disk and saves it every minute.
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