bochka vs Gcore
Gcore is a general cloud: you rent virtual machines, GPUs and serverless functions and set them up yourself. bochka is built for AI agents, so every sandbox is a VM that already has nested virtualization, a desktop, snapshots every minute and coding agents you drive from outside.
Where bochka stands out
A sandbox, not a server to assemble
A bochka sandbox starts with root, systemd, Docker and /dev/kvm ready, and saves its disk every minute and on stop. A Gcore VM gives you a clean Linux or Windows install, and you add Docker, backups and any agent tooling yourself. Gcore does not document nested virtualization on its cloud VMs.
Coding agents you drive from outside
bochka ships Claude Code, Codex, OpenCode and other agents inside each sandbox, and you drive agents inside from outside with a prompt, steer and events API. The credentials proxy keeps real AI keys out of the sandbox and can switch to another account when one runs out of credits. Gcore VMs have no agent layer; its Gclaw product is one chat-driven assistant.
Desktop, browser and forks built in
Every bochka sandbox has a 60fps desktop with Chromium, computer use and browser control, and you can embed the stream in your app. You can also fork a running sandbox to try two paths at once. Gcore offers a VNC console in its portal and new VMs from disk snapshots, which it says to take with the VM stopped.
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
Gcore
Gcore is a global cloud and edge provider: CDN, security, virtual machines, bare metal, GPUs and serverless functions.
Gcore Cloud rents Linux and Windows virtual machines with dedicated vCPUs in 30+ regions, plus GPU instances and clusters, managed Kubernetes and a functions service. You create machines from the portal, the API or Terraform, then install and run what you need on them. It is a general infrastructure cloud for any workload, not a sandbox product made for agents, so this page compares where the two overlap: a VM an agent can work in.
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 | Gcore: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A Gcore VM can run builds and Docker, but it has no documented /dev/kvm for emulators and no automatic snapshots, so it is a compromise for this work. | 3rd cheapest of 367 $634 a month | 80th of 367, with limits $681 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Gcore VMs stay up as long as you like, but you build the agent setup, the desktop and the backups yourself; bochka ships them in every sandbox. | 5th cheapest of 366 $657 a month | 118th of 366, with limits $706 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs fit Gcore better: it bills each VM per minute with no plan fee and has no start limits, while bochka's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 54th of 345, with limits $30 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month | Cheapest of 361 $209 a month | 39th of 361, with limits $232 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Thousands of short rollouts fit Gcore's per-minute VMs with no plan fee better than bochka's plans and start limits. | 34th of 360, with limits $2,000 a month | 16th of 360, with limits $967 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 | 8th cheapest of 364 $193 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 4th cheapest of 377 $86 a month | 5th cheapest of 377 $93 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 20th cheapest of 368 $28 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Gcore has a VNC console in its portal but no desktop image or computer-use API; bochka streams a 60fps desktop with Chromium you can drive and embed. | 6th cheapest of 369 $200 a month | 102nd of 369, with limits $193 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month On Gcore you install and run the browser yourself; bochka ships Chromium and browser control in every sandbox. | 7th cheapest of 367 $200 a month | 163rd of 367, with limits $97 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 | 155th of 346, with limits $46 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 | 41st of 338, with limits $910 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 | 111th of 360, with limits $48 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Gcore fits: it rents Nvidia GPUs by the hour, and bochka has no GPUs. | Can't run it | 39th of 98, with limits $802 a month |
| 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 | Gcore |
|---|---|---|
| Kind of product | Sandboxes for AI agents, each a full VM with tools ready | General cloud VMs you set up yourself, plus GPUs and functions |
| Nested virtualization | /dev/kvm on every machine, for emulators and VMs inside | Not documented for cloud VMs |
| Root and Docker | Root, systemd and Docker ready on every machine | Root through sudo or cloud-init; you install Docker yourself |
| Files after a stop | Snapshots every minute and on stop; a stopped sandbox costs nothing | Disks persist and are billed until deleted; snapshots on demand or on a schedule |
| Fork | Fork a running sandbox in one call | New VM from a boot disk snapshot; Gcore says to stop the VM first for consistency |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | VNC console in the portal; no desktop image or computer-use API |
| Reaching the machine | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | Public IPv4 you can move between machines, any port; TLS through your own server or a load balancer |
| Outbound internet | Open internet; no provider-side allowlist | Security groups limit outbound traffic by protocol, port and IP range |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | None on VMs; the separate Gclaw product runs one chat-driven agent |
| Keeping keys out of the machine | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Keys go onto the VM through user data or SSH |
| GPUs | None | Nvidia H100, H200, A100 and L40S by the hour |
| Operating systems and chips | Linux on AMD Ryzen 9 9950X hosts; Wine for Windows apps | Linux and Windows VMs, on x86 or Ampere Arm |
| Regions | EU only: Germany, Finland, France | 30+ regions across Europe, the Americas, Asia, Africa and Australia |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | No SOC 2 report published |
Every feature Battleships tracks (43)
| Feature | bochka | Gcore |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | Yes |
| 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 | Not published |
| 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 | Yes |
| 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 | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Not published |
| SSO | No | No |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: Gcore VMs were not in StarSling's public sandbox benchmark run. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB on dedicated AMD Ryzen 9 9950X (Zen 5) hosts. Gcore's Standard VMs use dedicated vCPUs, and their speed depends on which hardware generation you choose.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Gcore 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 | Gcore, 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 | $7 · Pay as you go |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $28 · Pay as you go |
| 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 | $340 · Pay as you go |
| 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 | $97 · 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 | $193 · Pay as you go |
bochka: 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.
Gcore: Gcore bills per minute while a VM runs, from a prepaid balance with no plan fee, and outgoing traffic is free. The prices shown use its cheapest Gen 0 Standard size and leave out the boot disk, which Gcore bills separately until you delete it, even while the VM is stopped. Prices exclude VAT and vary by region.
Limits in those scenarios
Gcore has no plan limits in these scenarios: no cap on how long a VM runs or how many start at once, only account quotas you raise by asking support. That is why the 1,000 short jobs fit there, while on bochka they get queued above 90 starts a minute and need more starts per day than the $2,000 plan allows. Gcore's own numbers leave the boot disk out, so every one of its scenarios costs a bit more than shown.
| Scenario | bochka | Gcore |
|---|---|---|
| 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 Gcore when
you need GPUs, Windows or Arm machines, servers outside Europe, or plain VMs next to the rest of a general cloud.
- GPUs in the same cloud. Useful if your agents train or run models: Gcore rents Nvidia H100, H200, A100 and L40S GPUs by the hour.
- Windows, Arm and many regions. Useful if you need Windows or Arm machines, or servers close to users outside Europe: Gcore runs in 30+ regions.
- Network rules and a whole cloud. Useful if machines must reach only chosen IP ranges, or sit next to a CDN, Kubernetes and private networks.
Use bochka when
you want agent sandboxes ready to work: a full VM with /dev/kvm, Docker, a desktop, snapshots every minute, forks and coding agents built in, without building that layer on top of raw VMs.
- A sandbox, not a server to assemble. Android emulators, Firecracker and other VMs inside need /dev/kvm, which Gcore does not document. Every other piece you add to a Gcore VM is setup code your team writes and keeps working.
- Coding agents you drive from outside. On a Gcore VM the agent's API keys sit on the disk where the agent's own code can read them, and you write the code that starts, prompts and watches each agent.
- Desktop, browser and forks built in. A computer-use agent on Gcore needs a desktop you install, a stream you host and a click API you write. Forking means stopping the VM, so the agent pauses each time.
Questions people ask
Is bochka cheaper than Gcore?
It depends on the work. One agent running all month comes to $26 a month on bochka against $28 on Gcore, and 50 agents in parallel to $317 against $340. Gcore is lower for one agent on workdays ($7 vs $20), for 300 user sandboxes ($97 vs $200) and for 1,000 short jobs ($193 vs $2,000, which also does not fit bochka's start limits), and its figures leave out the boot disk.
Can I use a Gcore VM as a sandbox for AI agents?
Yes, it is a full VM with root, so you can install Docker and an agent on it. You then add the rest yourself: backups, a desktop, a way to fork, key handling and the code that drives the agent. bochka ships those in every sandbox.
Does Gcore support nested virtualization?
Gcore does not document /dev/kvm or nested virtualization on its cloud VMs. Every bochka sandbox has /dev/kvm, so Android emulators, Firecracker and other VMs run inside it.
Does bochka have GPUs or Windows like Gcore?
No. bochka has no GPUs and no Windows guests; it runs Linux VMs on AMD Ryzen 9 9950X machines and has Wine docs for Windows apps. If you need GPUs, Windows or Arm machines, Gcore has all three.
Where does my data run?
bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Gcore runs in 30+ regions, including EU regions such as Luxembourg, Frankfurt and Warsaw, and you choose the region for each VM.
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. Gcore says its cloud meets GDPR, ISO 27001 and PCI DSS.
Start a sandbox
Install the CLI, then run bochka new.
Product preview