bochka vs Tencent Cloud SCF
Tencent Cloud SCF runs your code as short, stateless functions that start on each request and are taken back when idle. bochka gives each agent a whole Linux VM with Docker, a disk that stays and coding agents you drive from outside.
Where bochka stands out
A whole machine, not a function
A bochka sandbox is a full VM with root, Docker, systemd, SSH and /dev/kvm. An SCF function runs your handler or one web server on port 9000 inside an instance that Tencent manages and you cannot log into.
It keeps running and keeps its files
bochka has no session cap on paid plans, saves the whole disk every minute and on stop, and lets you fork a running sandbox. An SCF call ends after 900 seconds, or 24 hours with async execution, and Tencent's docs say local files may not be kept after the call.
Built for agents you drive from outside
Claude Code, Codex and other agents come preinstalled, and you prompt, steer and follow them 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 plus raw TCP.
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
Tencent Cloud SCF
Tencent Cloud SCF (Serverless Cloud Function) is Tencent Cloud's function-as-a-service: you upload code or a container image, and Tencent runs it when an event or HTTP request arrives.
SCF is not a sandbox product. It is a hyperscaler serverless platform: Tencent creates, reuses and deletes the function instances, you write your code to be stateless, and you pay for memory-seconds and invocations. It is built for event handlers, web APIs and background jobs inside Tencent Cloud, and it overlaps with bochka where you want to run code an agent wrote, or one short job per request.
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 | Tencent Cloud SCF: 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, keeps a repo checked out and works for hours does not fit a stateless function with a 900-second limit; bochka gives it a full VM with Docker and a disk that stays. | 3rd cheapest of 367 $634 a month | 231st of 367, with limits $2,977 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs memory of its files; SCF takes idle instances back and does not keep /tmp, so you would rebuild state from CFS or a database on every call. | 5th cheapest of 366 $657 a month | 261st of 366, with limits $3,841 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 SCF is built for: it starts an instance per request, bills per GB-second and needs no plan fee, while bochka's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 239th of 345, with limits $202 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Giving each of your users a machine that keeps their files is not how SCF works; each user would share stateless instances, while bochka gives every user a VM with HTTPS URLs on up to 50 ports. | Cheapest of 361 $209 a month | 260th of 361, with limits $1,292 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 98th of 360, with limits $6,071 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Both fit for short, stateless eval steps; bochka also keeps each eval machine's disk and lets you fork a running one to try two paths. | 10th cheapest of 364 $200 a month | 50th cheapest of 364 $982 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit simple test jobs, but SCF cannot run Docker or reach /dev/kvm, so image builds and Android emulators need bochka or a VM. | 4th cheapest of 377 $86 a month | 72nd cheapest of 377 $610 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and installed packages that stay; SCF has neither, while bochka keeps the whole disk and accepts SSH. | 18th cheapest of 368 $26 a month | 280th of 368, with limits $159 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month SCF runs headless instances with no desktop; bochka streams a full Linux desktop at 60fps with Chromium for computer-use agents. | 6th cheapest of 369 $200 a month | 231st of 369, with limits $914 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 | 255th of 367, with limits $475 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 | 264th of 346, with limits $358 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 | 182nd of 338, with limits $6,548 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 | 236th of 360, with limits $302 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 | Tencent Cloud SCF |
|---|---|---|
| What you get | A full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | A function instance that Tencent starts, reuses and deletes; you cannot manage it |
| How long it runs | No session cap on paid plans; a sandbox can run all month | Up to 900 seconds per call; async functions up to 24 hours, chosen at creation |
| Docker, systemd and root | Root, Docker and systemd inside every sandbox | No Docker daemon inside a function; a container image can be the function itself |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not offered |
| Shell access | SSH into any sandbox | No SSH into instances |
| Files after a stop | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing | 512 MB /tmp that may not be kept after the call; CFS network file systems you mount and pay for |
| Snapshots and fork | Automatic snapshots every minute; fork a running sandbox with its disk | None; code versions and aliases only |
| Scale to zero | You stop a sandbox through the API or a TTL and start it again through the API; no wake on request | Instances start on each request and are taken back when idle |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected; raw TCP; SSH | Function URLs or API Gateway to one web server on port 9000; no raw ports |
| Network controls | Open internet, no provider-side allowlist | Public network on or off per function, VPC placement and a fixed outbound IP |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | None; you package your own code |
| 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 | Keys go into environment variables inside the function |
| GPUs | None | Nvidia T4 and A10 GPU functions |
| Regions | EU only (Germany, Finland, France) | Mainland China, Hong Kong, Singapore, Tokyo, Silicon Valley and Frankfurt |
| 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 | Tencent Cloud SCF |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| 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 | 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 | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Not published |
| 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 | No |
| GPU | No | Yes |
| Windows | No | No |
| Arm64 | No | No |
| 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 | 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: SCF 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. On SCF the CPU share follows the memory you set, so a fair test would need its own run at a matching size.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tencent Cloud SCF 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 | Tencent Cloud SCF, 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 | $41 · 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 | $166 · 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,944 · 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 | $585 · 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,219 · Pay as you go |
bochka: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Tencent Cloud SCF: SCF bills the memory you set times the seconds a call runs, at USD 0.0000167 per GB-second, plus USD 0.002 per 10,000 invocations and outbound traffic per GB. A basic package of USD 0.06 a day, with a small free quota, is charged in months with usage; CPU is not billed on its own because it follows memory.
Limits in those scenarios
The three agent scenarios do not fit SCF: there is no persistent disk, so files are lost when an instance is taken back, and the agent fleet also needs Docker inside. The always-on agent hits the 24-hour cap even with async execution, and normal calls stop after 900 seconds. A 4 vCPU / 8 GiB function needs a large-specification application, since the default memory limit is 3,072 MB, and each region has a shared concurrency quota of 64,000 or 128,000 MB. bochka is the one that does not fit the burst: 1,000 short jobs at once need more starts per day than the $2000 plan allows, and starts above 90 per minute are queued.
| Scenario | bochka | Tencent Cloud SCF |
|---|---|---|
| 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 Tencent Cloud SCF when
your work is many short, stateless calls or GPU inference that should scale to zero, especially inside Tencent Cloud or for users in China and Asia.
- Per-request scale and bursts. Workloads made of many short, stateless calls start one instance per request and pay only for the memory-seconds they use.
- GPU functions. Teams that run model inference or image generation as functions can pick Nvidia T4 or A10 GPUs, billed by memory and time.
- China, Asia and Tencent Cloud. Teams serving users in mainland China or Asia can run next to their Tencent Cloud VPC, databases and storage.
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 function. Coding agents run docker build, start databases and open emulators. In an SCF function those commands have nowhere to run, so you would move the agent to a CVM server and manage that machine yourself.
- It keeps running and keeps its files. Without it, every call repeats the clone, the installs and the build. On SCF you can mount a CFS file system, but it must be in the same VPC, it is billed on its own, and there is still no snapshot or fork.
- Built for agents you drive from outside. On SCF you build the agent loop, the preview routing and the key handling yourself, and keys sit in environment variables inside the function, where code the agent wrote can read them.
Questions people ask
Is bochka cheaper than Tencent Cloud SCF?
For agents that work for hours, yes: one coding agent on workdays comes to $20 a month on bochka against $41 on SCF, and 50 agents in parallel come to $317 against $1,944, though SCF cannot keep their files. For 1,000 short jobs at once SCF costs less, $1,219 against $2,000, and it fits where bochka's start limits do not.
Can an AI coding agent run on Tencent Cloud SCF?
Only for short steps. An SCF call ends after 900 seconds, or 24 hours with async execution, there is no Docker or SSH inside, and local files may not be kept after the call. bochka gives each agent a full VM that runs as long as you like and keeps its disk.
Can I run Docker inside an SCF function?
No. You can deploy a container image as the function, but it runs one job or one web server on port 9000, and there is no Docker daemon inside. bochka runs Docker inside every sandbox, along with systemd and /dev/kvm.
Do files survive between SCF calls?
Not reliably. Each function has 512 MB of /tmp, and Tencent's docs say it may not be kept after the call ends. For files that last you mount a CFS network file system from the same VPC. bochka keeps the whole disk and saves it every minute.
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. SCF runs in mainland China, Hong Kong, Singapore, Tokyo, Silicon Valley and Frankfurt.
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