Azure Container Apps Sandboxes vs smol machines
Both give each agent its own microVM with its own kernel and can copy a running machine with its memory. Azure Container Apps Sandboxes lives inside your Azure account with strict outbound rules and 40 regions, while smol machines is an open-source engine that runs the same VM on your laptop, in its hosted cloud or on your own servers.
The companies and products
Azure Container Apps Sandboxes
Azure Container Apps Sandboxes is a service inside Microsoft Azure that gives each agent or user an isolated microVM you create, suspend and resume through an SDK.
It is part of Azure Container Apps, the hyperscaler's serverless container platform, and lives in your Azure subscription as a sandbox group resource. Each sandbox boots from an OCI image or a snapshot, has its own kernel, and can be suspended with its memory and resumed in under a second. It is built for teams already on Azure that want stateful code execution with Azure networking, identity and billing.
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
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. “34th cheapest of 345” means 33 of the other 344 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 | Azure Container Apps Sandboxes: price rank | smol machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 288th of 367, with limits $5,276 a month | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 302nd of 366, with limits $6,544 a month | 148th of 366, with limits $1,038 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 Both fit short code runs; smol machines ranks 12th with a one-minute minimum and pay-for-what-the-guest-uses billing, and Azure ranks 34th with memory suspend and sub-second resume. | 34th cheapest of 345 $354 a month | 12th cheapest of 345 $140 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 Both fit sandboxes for your users, and both start a stopped machine again on the next request; bochka ranks 1st, adding a desktop, hosting on up to 50 ports and a credentials proxy. | 22nd cheapest of 361 $2,260 a month | 7th cheapest of 361 $531 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 Both can copy a running machine with its memory, so many rollouts start from one prepared state; smol machines branches pay the one-minute minimum once rather than per clone. | 153rd of 360, with limits $10,740 a month | 111th of 360, with limits $6,978 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 Both fit agent evals; smol machines has a registry image with the Harbor eval harness, and Azure has Copilot CLI and Claude Code images run through exec. | 75th cheapest of 364 $1,728 a month | 36th cheapest of 364 $670 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 CI that builds Android apps or boots VMs needs nested virtualization, which neither Azure nor smol cloud exposes and bochka does through /dev/kvm. | 103rd cheapest of 377 $1,046 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box wants SSH, which neither offers; Azure also bills every running second, so a box left on all month only gets close with a 3-year commitment. | 322nd of 368, with limits $262 a month | 216th of 368, with limits $29 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 Computer-use agents need a screen; both Azure and smol cloud are headless, while bochka streams a Linux desktop at 60fps with computer-use tools. | 279th of 369, with limits $1,573 a month | 90th of 369, with limits $156 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 Neither ships a managed browser: on Azure you install one in your image, and smol machines has a guide for running your own Chromium. | 288th of 367, with limits $795 a month | 176th of 367, with limits $136 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 | 284th of 346, with limits $561 a month | 241st of 346, with limits $242 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 | 239th of 338, with limits $10,956 a month | 148th of 338, with limits $4,344 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 | 278th of 360, with limits $517 a month | 252nd of 360, with limits $377 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 | Azure Container Apps Sandboxes | smol machines | bochka |
|---|---|---|---|
| Isolation | MicroVM per sandbox with its own kernel | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Biggest machine | Tiers up to 4 cores / 8 GB; up to 16 vCPU / 32 GB by API | Up to 32 vCPU / 32 GB on Startup, 16 vCPU / 24 GB on Pro | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Stop, suspend and wake | Suspend with memory and disk, resume in under a second with processes running; traffic wakes it | Filesystem survives a stop, memory paths are emptied; a command or request starts it again; stopped disk keeps billing | Disk is saved every minute and on stop; a stopped sandbox costs nothing and is started by API |
| Copy a running machine | Snapshot a running sandbox with its memory and create new sandboxes from it | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk |
| Nested virtualization | Not documented | Not exposed in the cloud API; a local smolvm flag only | Yes, /dev/kvm for Android emulators and VMs |
| Docker inside | Depends on the image: azure-dev ships Docker on systemd; the default ubuntu image has only Buildah | Docker runs inside the VM, with its data on the machine's ext4 disk | Docker, systemd and root on every sandbox |
| Getting a shell | Interactive shell through the aca CLI, SDK or portal; no SSH | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound access | Public HTTPS routes per published port; private endpoint from your VNet; no public IP | Up to 16 published ports through a returned URL or an authenticated connect route; no dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Allow, deny, rewrite and header rules by host, path and method; VNet integration | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Desktop, browser and computer use | Headless; no desktop or managed browser | No hosted desktop; a guide shows running your own Chromium | Linux desktop streamed at 60fps, Chromium and computer-use tools preinstalled |
| Coding agents | Copilot CLI and Claude Code images, run through the exec API | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Group secrets usable in egress header rules; Copilot and Anthropic tokens are injected into the sandbox at startup | Cloud secrets are environment variables the guest can read; key swapping only in self-hosted smolvm | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | 40 Azure regions, 9 of them in the EU | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | No; runs only inside an Azure subscription | Open-source smolvm runs on your laptop or your own servers with the same .smolmachine artifact | No; hosted service |
Every feature Battleships tracks (43)
| Feature | Azure Container Apps Sandboxes | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | Yes | 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 | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither Azure Container Apps Sandboxes nor smol cloud has a comparable CPU measurement yet, so this page makes no speed claim between them. bochka did 26.69 runs per second on the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms for smolvm, which is a start-time figure, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Azure Container Apps Sandboxes and smol machines 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 | Azure Container Apps Sandboxes, a month | smol machines, 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 | $68 · Pay-as-you-go | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $262 · Pay-as-you-go · with limits | $93 · Standard | $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 | $3,421 · Pay-as-you-go | $1,139 · Pro | $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 | $989 · Pay-as-you-go | $465 · Startup | $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,148 · Pay-as-you-go | $1,389 · Startup | $2,000 · $2000/mo · with limits |
Azure Container Apps Sandboxes: Azure bills per second on the Container Apps Consumption meters for the vCPU and memory of the sandbox's tier while it runs, including idle time before auto-suspend (5 minutes by default). There is no plan fee, stopped sandboxes pay no CPU or memory, and some regions such as West Europe charge more.
smol machines: smol cloud charges $0.04 for every hour a machine runs plus $0.05 per active vCPU-hour and $0.0162 per active GB-hour of memory, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.
smol machines: 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.
Limits in those scenarios
Azure has no session cap, but it bills a running sandbox every second, so one agent that never stops only gets close with a 3-year commitment. Azure's default quota is 500 active cores, raised by support request, and Docker inside means picking an image like azure-dev. smol machines caps machines by plan, 20 on Standard, 100 on Pro and 1,000 on Startup, with stopped machines still holding a slot, so 50 agents needs Pro and 1,000 short jobs at once needs Startup. bochka's tighter limit is starts: at 1,000 short jobs at once its $2,000 plan queues starts above 90 a minute.
| Scenario | Azure Container Apps Sandboxes | smol machines | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel | None that bite | None that bite | None that bite |
| Sandboxes for your users | None that bite | None that bite | None that bite |
| 1,000 short jobs at once | None that bite | None that bite |
|
Which one should you use?
Use Azure Container Apps Sandboxes when
your team already runs on Azure and wants sandboxes that suspend with their memory, wake on traffic, sit behind per-request egress rules, or run in a region outside the EU.
- Memory suspend and wake on traffic. For stateful jobs that sleep between requests: a sandbox suspends with its memory and resumes in under a second with processes running.
- Fine-grained outbound rules. Its egress policy can allow, deny or rewrite each outbound request by host, path and method, and join your Azure VNets.
- Inside Azure, in 40 regions. Teams already on Azure get Entra ID sign-in, Azure billing and their own networks, in 40 regions around the world.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, fan out many branches of a running machine, or need arm64 or 32 vCPU machines.
- Open source, laptop to your own servers. One open-source engine, smolvm, runs the same machine on your laptop, in smol cloud or on servers you run yourself.
- Live branches that pay once. Branch a running machine with its memory and processes, and the one-minute minimum is paid once, not per clone.
- Bigger machines and arm64. Startup machines go up to 32 vCPU / 32 GB, and registry images come in both amd64 and arm64.
Where bochka fits
Azure Container Apps Sandboxes and smol machines are both good at short, stateful microVMs that sleep and wake. If your agents instead work for hours like a person at a computer, installing tools, running emulators, using a browser and serving apps, bochka gives each one a whole machine with that built in.
A whole computer you can SSH into
Neither Azure nor smol cloud offers SSH or exposes /dev/kvm, so an agent cannot start an Android emulator or a VM, and SSH tools must be rewired to an exec API. bochka has both, plus raw TCP and 50 HTTPS ports.
A screen and a browser for every agent
Both are headless: for a computer-use agent you build, package and maintain a browser, a virtual display and a stream in your own image. bochka streams a Linux desktop at 60fps with Chromium and computer use ready.
Agents you drive from outside, keys kept outside
On both, coding agents run through raw exec calls, and model tokens or secrets sit inside the sandbox where a prompt injection can read them. bochka drives seven agents inside from outside by API, and real keys stay in a credentials proxy.
Use bochka when your agents need a whole computer for real work: SSH, Docker, emulators, a desktop and a browser, with coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: bochka vs Azure Container Apps Sandboxes and bochka vs smol machines.
Questions people ask
Is Azure Container Apps Sandboxes cheaper than smol machines?
No, smol machines costs less in all five scenarios on this page, for example $68 vs $25 a month for one coding agent on workdays. Azure bills the full tier while a sandbox runs, while smol bills the CPU and memory the guest actually uses plus a base fee per running hour.
Which is faster, Azure Container Apps Sandboxes or smol machines?
Neither has been measured on the same CPU test yet, so there is no fair answer. bochka did 26.69 runs per second on the StarSling Node.js build-and-test loop at 4 vCPU / 8 GB.
Can I run Docker in Azure Container Apps Sandboxes and smol machines?
Yes on both, with care. Azure's azure-dev image ships Docker on systemd, while the default ubuntu image has only Buildah; smol says Docker data must live on the machine's ext4 disk. bochka runs Docker on every sandbox and also exposes /dev/kvm for emulators and VMs.
Can I SSH into either one?
No. Azure gives a shell through the aca CLI, SDK or portal, and smol cloud gives a command API and a WebSocket terminal capped at one hour per connection. Every bochka sandbox has an SSH endpoint.
Can I self-host smol machines or Azure Container Apps Sandboxes?
smol machines, yes: the smolvm engine is open source and runs on macOS, Linux and Windows hosts. Azure Container Apps Sandboxes runs only inside an Azure subscription, and bochka is a hosted service only.
Do they keep API keys out of the sandbox?
Not fully. Azure can use group secrets in egress header rules, but its Copilot and Anthropic tokens are injected into the sandbox at startup, and smol cloud secrets are plaintext inside the guest. bochka's credentials proxy keeps real keys outside for model providers and any HTTPS API.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs Azure Container Apps Sandboxes
- bochka vs smol machines
- E2B vs Azure Container Apps Sandboxes
- Daytona vs Azure Container Apps Sandboxes
- Modal vs Azure Container Apps Sandboxes
- Vercel Sandbox vs Azure Container Apps Sandboxes
- Cloudflare Sandbox vs Azure Container Apps Sandboxes
- Blaxel vs Azure Container Apps Sandboxes
- Runloop vs Azure Container Apps Sandboxes
- Tensorlake vs Azure Container Apps Sandboxes
- Morph Cloud vs Azure Container Apps Sandboxes
- CodeSandbox SDK vs Azure Container Apps Sandboxes