AWS EC2 vs Google Compute Engine
AWS EC2 and Google Compute Engine are both hyperscaler VM services: you rent a machine with its own kernel and build everything else yourself. EC2 adds Mac hosts and came in lower on list price in every scenario we priced, while Compute Engine allows nested KVM on more machine families and runs in a few more regions.
The companies and products
AWS EC2
AWS EC2 is Amazon's general-purpose cloud VM service, not a sandbox product: you rent virtual servers by the second and set them up yourself.
You pick an instance type (Intel, AMD, Graviton Arm, GPU or Mac), a machine image and a network, and EC2 boots a Nitro VM with its own kernel and root access. Disks are EBS volumes, inbound traffic goes through security groups, and anything agent-specific (agents, desktops, HTTPS URLs, key handling) is yours to build. It is built for every kind of server workload, from websites to GPU training, across AWS's worldwide regions.
Google Compute Engine
Google Compute Engine is Google Cloud's general-purpose VM service, not a sandbox product: you rent virtual machines by the second and set them up yourself.
You pick a machine type (E2, N2D, C3D, Arm T2A, GPU families and more), a boot image and a network, and Compute Engine boots a KVM-based VM with its own kernel and root access. Disks are Persistent Disk or Hyperdisk volumes, traffic goes through VPC firewall rules, and anything agent-specific (agents, desktops, HTTPS URLs, key handling) is yours to build. It is built for every kind of server workload, from websites to GPU training, across Google Cloud's worldwide regions.
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. “5th cheapest of 364” means 4 of the other 363 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 | AWS EC2: price rank | Google Compute Engine: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month AWS EC2 ranks 87th and Google Compute Engine ranks 120th, since on both you build the agent setup, preview URLs and cloning yourself; bochka ranks 3rd with them built in. | 87th of 367, with limits $775 a month | 120th of 367, with limits $1,106 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 114th of 366, with limits $646 a month | 177th of 366, with limits $1,433 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 Short bursts suit both clouds better than bochka's start limits allow, and Google Compute Engine ranks 92nd against 102nd for AWS EC2. | 102nd of 345, with limits $165 a month | 92nd of 345, with limits $133 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 On both clouds you build HTTPS access, isolation per user and lifecycle tooling yourself; bochka ranks 1st here because it ships them for each sandbox. | 70th of 361, with limits $607 a month | 92nd of 361, with limits $836 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 AWS EC2 ranks 13th for RL rollouts and Google Compute Engine ranks 36th; both can launch big fleets once your quota is raised. | 13th of 360, with limits $830 a month | 36th of 360, with limits $2,085 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 Agent evals fit all three fully; AWS EC2 ranks 5th, bochka ranks 10th and Google Compute Engine ranks 16th. | 5th cheapest of 364 $177 a month | 16th cheapest of 364 $263 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 fits both clouds, but builds that need /dev/kvm only work on some machine families there, while bochka ranks 4th with /dev/kvm on every machine. | 21st cheapest of 377 $255 a month | 41st cheapest of 377 $359 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 59th cheapest of 368 $76 a month | 82nd cheapest of 368 $109 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 Neither cloud's Linux images have a desktop or computer-use API, so you install and stream one yourself; bochka ranks 6th with a 60fps desktop ready. | 103rd of 369, with limits $195 a month | 129th of 369, with limits $293 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 | 165th of 367, with limits $101 a month | 212th of 367, with limits $244 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 | 195th of 346, with limits $116 a month | 218th of 346, with limits $179 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 | 82nd of 338, with limits $2,046 a month | 108th of 338, with limits $2,978 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 | 108th of 360, with limits $45 a month | 152nd of 360, with limits $120 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 Only AWS EC2 is priced for GPU jobs here, at rank 25; Compute Engine's GPUs are not in our tables, and bochka has no GPUs. | 25th cheapest of 98 $1,723 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 | Can't run it |
Key features
| Feature | AWS EC2 | Google Compute Engine | bochka |
|---|---|---|---|
| What you get | A general cloud VM; you install and wire everything else | A general cloud VM; you install and wire everything else | An agent sandbox: a full VM with agents, desktop, URLs and snapshots set up |
| Isolation | Every instance is a Nitro VM with its own kernel | Every instance is a KVM-based VM with its own kernel | Every sandbox is a full VM with its own kernel |
| Docker and nested virtualization | Docker, root and systemd on any instance; /dev/kvm only on C8i, M8i, R8i and metal instances | Docker, root and systemd on any VM; nested KVM only on some Intel families and N4D, enabled per VM, not on E2, Arm or other AMD VMs | Docker, root, systemd and /dev/kvm on every machine |
| Coding agents | None preinstalled; you install agents and drive them over SSH or Systems Manager | None preinstalled; you install agents and drive them over SSH or startup scripts | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the machine | No credential proxy; IAM role credentials and secrets are read from inside the instance | No credential proxy; service account tokens and Secret Manager values are read from inside the VM | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Desktop and computer use | Linux images have no desktop; Windows instances have Remote Desktop; no computer-use API | No managed desktop, browser or computer-use API on Linux VMs | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Reaching the machine | Public IPv4 and any port through security groups; HTTPS needs your own domain, certificate and a load balancer or web server | External IPv4 and any port through firewall rules; HTTPS needs your own certificate and a load balancer or web server | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Files after a stop | EBS disks are kept and billed while stopped; snapshots are manual or scheduled with Data Lifecycle Manager | Persistent disks are kept and billed while stopped; snapshots are on demand or on a schedule you set | Snapshots every minute and on stop; a stopped sandbox costs nothing |
| Copying a machine | Make an image and boot a new instance from it | Make a machine image (disks, not memory) and boot a new VM from it | Fork a running sandbox |
| Pausing with memory | Hibernation saves memory to disk and resumes the same instance | Suspend keeps memory for up to 60 days, and the memory keeps billing while suspended | No memory snapshots; resume reboots from disk |
| Outbound network rules | Security group rules per instance; domain allowlists with AWS Network Firewall or DNS Firewall (paid) | VPC egress firewall rules by IP and port; domain rules on Cloud NGFW Standard (paid) | Open internet on every plan; no provider-side allowlist |
| GPUs | Nvidia GPU instances, from L4 and L40S up to H100 and H200 | Nvidia GPUs from T4 and L4 up to H100, H200, B200 and GB200 | None |
| Operating systems and CPUs | Linux and Windows on Intel, AMD and Graviton Arm; macOS on Mac Dedicated Hosts (24-hour minimum) | Linux and Windows Server on Intel, AMD and Arm; no macOS | Linux on AMD Ryzen 9 9950X (Zen 5); Wine for Windows apps |
| Regions | 39 regions and 124 availability zones, including several in the EU | 43 regions and 130 zones, including many in the EU | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | AWS EC2 | Google Compute Engine | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | Yes | Yes | Yes |
| Public IPv4 | Yes | Yes | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | Yes | No |
| Windows | Yes | No | No |
| Arm64 | Yes | Yes | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for EC2 or Compute Engine: neither was part of the public benchmark run we use. In that run, StarSling's Node.js build-and-test test on 2026-09-29, bochka did 26.69 runs per second at 4 vCPU / 8 GB. Speed on both clouds depends on the machine family you pick.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. AWS EC2 and Google Compute Engine 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 | AWS EC2, a month | Google Compute Engine, 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 | $21 · Pay-as-you-go (no platform fee) | $31 · Pay-as-you-go billing account (no plan fee) | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $51 · Pay-as-you-go (no platform fee) · with limits | $64 · Pay-as-you-go billing account (no plan fee) · 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 | $944 · Pay-as-you-go (no platform fee) | $1,291 · Pay-as-you-go billing account (no plan fee) | $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 | $269 · Pay-as-you-go (no platform fee) | $378 · Pay-as-you-go billing account (no plan fee) | $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 | $502 · Pay-as-you-go (no platform fee) | $690 · Pay-as-you-go billing account (no plan fee) | $2,000 · $2000/mo · with limits |
AWS EC2: EC2 bills each instance per second with a 60 second minimum, here the Graviton c7g sizes on demand, with no platform fee. EBS disks and public IPv4 addresses bill on top, also while stopped.
Google Compute Engine: Compute Engine bills each VM per second after a 1 minute minimum, here E2 sizes on demand in us-central1, with no platform fee. Disks and external IPs bill on top while they exist, and a suspended VM keeps billing its memory.
Google Compute Engine: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
A new AWS account can run only 5 vCPUs of standard On-Demand instances per region, which is one 4 vCPU machine, until AWS raises it. Compute Engine sets per-region CPU quotas that vary by project, some new projects also have a global CPU cap, and a free trial account cannot ask for more. So 50 agents in parallel or 300 sandboxes for your users need a quota request first on both, and on both one agent that never stops reaches the price shown only with a 3-year commitment. On bochka, the 1,000-job burst is the one that does not fit: the $2,000 plan allows 90 starts a minute, 600 an hour and 2,400 a day, so the burst is queued.
| Scenario | AWS EC2 | Google Compute Engine | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops |
|
| 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 AWS EC2 when
you need macOS or Windows alongside Linux, Graviton Arm machines, or the lowest list price of the two clouds in our scenarios, and you have the people to build agent tooling on top.
- Mac hosts for macOS work. Useful if your agents need macOS or Xcode: EC2 rents Mac instances on Dedicated Hosts, and Compute Engine has no macOS.
- Lower list prices in our scenarios. EC2's Graviton sizes came in below Compute Engine's E2 sizes in all five scenarios we priced, though E2 gives more memory.
Use Google Compute Engine when
you want nested KVM on more machine families, more memory per vCPU in the sizes we priced, or a Google Cloud region near your users, and you will build the agent tooling yourself.
- Nested KVM on more machine families. Useful if your agents need /dev/kvm: Compute Engine allows it on Intel families such as N2, C3 and N4, plus N4D.
- More memory in the sizes we priced. Useful for memory-hungry agents: the E2 sizes we priced give twice the memory of EC2's c7g sizes, such as 16 GiB on 4 vCPUs.
- A few more regions. Useful if you need a VM close to users in a specific place: Google Cloud runs 43 regions and 130 zones.
Where bochka fits
EC2 and Compute Engine are general clouds, so the choice between them often comes down to GPUs, macOS, regions and the account you already have. If what you are really running is agents, both hand you a bare VM and leave the agent setup, desktops, URLs and copies to you. bochka gives each agent a full VM with all of that ready, in the EU.
Coding agents you drive from outside
On EC2 and Compute Engine you write the code that installs, prompts and watches each agent, and IAM or service account tokens sit inside the VM where any root process can read them. bochka ships the agents, an API and a credentials proxy.
/dev/kvm, minute snapshots and forks everywhere
EC2 gives /dev/kvm only on C8i, M8i, R8i and metal, Compute Engine not on E2, Arm or most AMD VMs. On both, a copy means an image and a fresh boot, and parked disks keep billing.
Desktop, browser and HTTPS URLs ready
A computer-use agent on either cloud needs you to install a desktop, a streaming server and a click API, and every preview URL needs a certificate plus a load balancer or web server. bochka has a 60fps desktop and HTTPS on 50 ports.
Use bochka when you are running agents and want each one on a ready, full VM: coding agents with an API, keys kept outside, /dev/kvm, a desktop, HTTPS URLs, minute-by-minute snapshots and forks, with no infrastructure to assemble. Compare it one to one: bochka vs AWS EC2 and bochka vs Google Compute Engine.
Questions people ask
Is AWS EC2 cheaper than Google Compute Engine?
On list price, in all five scenarios we priced, yes. 50 agents in parallel come to $944 a month on EC2 against $1,291 on Compute Engine, and the 1,000-job burst to $502 a month against $690. The E2 sizes we priced carry twice the memory, and bochka came in at $317 a month for the 50 agents.
Which is faster, EC2 or Compute Engine?
We have no comparable measurement for either: neither was in the public benchmark run we use. Speed on both depends on the machine family you pick. bochka did 26.69 runs per second at 4 vCPU / 8 GB in that run.
Can EC2 and Compute Engine run Docker and nested virtualization?
Both run Docker with root and systemd on any VM. EC2 offers KVM inside virtual C8i, M8i and R8i instances and metal instances. Compute Engine offers Linux KVM on some Intel families and N4D, enabled per VM, but not on E2, Arm or other AMD VMs; bochka has /dev/kvm on every machine.
Do EC2 and Compute Engine support macOS and Windows?
EC2 runs Linux and Windows and rents Mac instances on Dedicated Hosts with a 24-hour minimum. Compute Engine runs Linux and Windows Server but has no macOS. bochka runs Linux only, with Wine for Windows apps.
Which has more regions?
Compute Engine runs in 43 regions and 130 zones, and EC2 in 39 regions and 124 availability zones, both including several in the EU. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
How does bochka compare to EC2 and Compute Engine for agents?
bochka is an agent sandbox rather than a general cloud: each sandbox is a full VM with coding agents, a desktop, HTTPS URLs, /dev/kvm, minute snapshots and forks ready. It has no GPUs, Windows or macOS, and its start limits do not fit a 1,000-job burst, where both clouds do.
Try bochka
Install the CLI, then run bochka new.
Product preview