bochka vs Trigger.dev

Trigger.dev is a platform for durable background jobs and AI agents that you write in TypeScript: it runs each job in a container, retries it and pauses it while it waits. bochka gives each agent a whole Linux VM with root, Docker, a desktop and open ports, for work that needs a real machine rather than a function.

Where bochka stands out

A whole machine, with Docker inside

On bochka each agent gets its own VM with root, systemd, Docker and /dev/kvm. It can install packages, start a database, build images and run emulators the way a developer would. A Trigger.dev run is your task code in a container, and anything it needs must be baked in at deploy time through build extensions.

A machine you can reach and keep

A bochka sandbox has SSH, HTTPS URLs on up to 50 ports, raw TCP and its own IP, and its disk persists with snapshots every minute. You can fork a running one to try two ideas at once. A Trigger.dev run has no inbound ports, and its 10 GB disk lasts only as long as the run.

Coding agents built in, keys kept out

bochka ships Claude Code, Codex, OpenCode and other agents inside each sandbox, and you drive them from outside with a prompt, steer and events API. Its credentials proxy lets them call model providers and any HTTPS API while the real keys never enter the sandbox. Trigger.dev's chat.agent is a strong way to build your own agent, but you write it, and secrets reach the task as environment variables.

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
Hardware: Dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Regions: EU: Germany, Finland, France
Plans: From $20 a month, all of it usage credit, 7-day trial

Trigger.dev

Trigger.dev is an open-source platform for building and running durable AI agents and workflows in TypeScript. It is a job platform, not a sandbox you log into.

You write tasks in TypeScript, deploy them, and Trigger.dev packages your code into a container image and runs each task run in its own isolated container, with retries, queues, schedules and live streams to your frontend. When a run waits for a subtask, a timer or a message, it is checkpointed with CRIU and you are not billed for the wait. It is built for product teams that ship background jobs and chat agents, and the whole stack can be self-hosted.

Founded: 2022, Y Combinator Winter 2023, based in London
Isolation: Your code is packaged into a Docker image; each run executes in an isolated container
Machines: Seven presets from 0.25 vCPU / 0.25 GB to 8 vCPU / 16 GB, each with 10 GB of disk
Run length: No execution timeout; a queued run waits at most 14 days for a slot
Regions: You pick the region a run executes in (for example eu-central-1); this does not move where payloads, outputs and logs are stored
Source code: Apache 2.0; self-host with Docker Compose or Kubernetes, without checkpoints, warm starts or auto-scaling
Compliance: Says it is SOC 2 Type II compliant; a HIPAA BAA is a paid add-on

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	Trigger.dev: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, databases and a shell for each agent; Trigger.dev runs your task code in a container with neither Docker inside nor a way to log in.	3rd cheapest of 367 $634 a month	350th of 367, with limits $14,797 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Trigger.dev's chat.agent sleeps between messages and wakes on the next one, which suits chat assistants, but each assistant is a task you write, not a machine it can install things on.	5th cheapest of 366 $657 a month	87th of 366, with limits $19,211 a month
Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs are where Trigger.dev comes closest: it bills per second only while a run executes, so it lands at $1,008 a month against $2,000 on bochka, though neither is a full fit.	186th of 345, with limits $2,000 a month	304th of 345, with limits $1,008 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 sandbox means a machine they can reach and keep; Trigger.dev runs have no inbound ports and start from a fresh disk each time.	Cheapest of 361 $209 a month	334th of 361, with limits $6,479 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	194th of 360, with limits $30,615 a month
Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Both fit agent evals: Trigger.dev fans runs out with batchTrigger and retries, and bochka gives each eval its own VM with Docker and a fork of a running setup.	10th cheapest of 364 $200 a month	88th cheapest of 364 $5,076 a month
CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs often build and run containers, and Trigger.dev documents no Docker inside a run; bochka runs Docker and /dev/kvm on every machine.	4th cheapest of 377 $86 a month	358th of 377, with limits $2,938 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB	18th cheapest of 368 $26 a month	357th of 368, with limits $763 a month
Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Trigger.dev can run headless Playwright or Puppeteer from a build extension, but it has no desktop to stream or click; bochka streams a 60fps desktop.	6th cheapest of 369 $200 a month	346th of 369, with limits $4,407 a month
Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Trigger.dev installs Chromium, Firefox or WebKit for Playwright in one config line, which covers scripted browsing; bochka adds a visible desktop and computer use.	7th cheapest of 367 $200 a month	145th of 367, with limits $2,204 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	137th of 346, with limits $1,492 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	304th of 338, with limits $29,996 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	90th of 360, with limits $1,474 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	Trigger.dev
What you get	A Linux VM that you or your agent drive: shell, files, processes and ports	A runtime for TypeScript tasks you deploy; each run starts from your code and payload
Isolation	Every sandbox is a full VM with its own kernel	Each run executes in an isolated container built from your code
Docker, root and nested virtualization	Docker, root, systemd and /dev/kvm on every machine	No Docker inside a run and no /dev/kvm documented; system packages come from build extensions
Machine sizes	4 vCPU / 8 GB by default, up to 8 vCPU / 16 GB on the $20 plan and 16 vCPU / 32 GB from $100	0.25 vCPU / 0.25 GB up to 8 vCPU / 16 GB, each with 10 GB of disk
Files over time	A disk that persists, snapshots every minute and on stop; a stopped sandbox costs nothing	Kept across waits inside one run by the checkpoint; the next run starts fresh
Waiting and waking	Stop and start by API; a start reboots from disk	Waits of 60 seconds or more are checkpointed with memory and are free; the run wakes on a timer, subtask, token or message
Fork	Fork a running sandbox into a new one	No fork; a replay runs the task again from its payload
Getting in from outside	SSH, HTTPS URLs on up to 50 ports, raw TCP and its own IP	No SSH or inbound ports; static outbound IPs on paid plans and PrivateLink on Pro
Browser and desktop	60fps desktop and Chromium, computer use and browser control	Playwright or Puppeteer with Chromium, Firefox or WebKit through a build extension; no desktop
Coding agents	Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API	chat.agent and AgentChat for agents you write with the AI SDK; an MCP server for your editor
Keeping keys out of the code	AI credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox	Secrets are environment variables, hidden in the dashboard, delivered to the task process
Workflow engine	None built in; you run your own scheduler or queue on the VM	Retries, queues, concurrency keys, cron schedules, batch triggers and live streams to React
Open source and self-hosting	Managed service only	Apache 2.0; self-host with Docker Compose or Kubernetes
Regions	EU only: Germany, Finland, France, with EU data residency	Pick the region a run executes in, in the US or EU; stored data does not move with it
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	Trigger.dev
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	Yes
Computer-use API	Yes	No
SSH	Yes	No
Persistent disk	Yes	Yes
Pause/resume	Yes	Yes
Automatic snapshots	Yes	Yes
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	No
Raw TCP inbound	Yes	Not published
Public IPv4	No	No
Egress allowlist	No	No
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	No
Self-hosting	No	Yes
BYOC	No	No
Open source	No	Yes
Scoped API keys	Yes	Yes
Spend limits	Yes	Yes
Usage per sandbox (API)	Yes	No
Audit logs	No	Not published
SSO	No	Yes
SOC 2	No	Yes
HIPAA	No	Yes
EU data residency	Yes	No
Zero data retention	Yes	Not published

Performance

bochka26.69 runs/s

Trigger.devNot measured

There is no comparable measurement: Trigger.dev was not part of the public StarSling sandbox benchmark. bochka did 26.69 Node.js build-and-test runs per second there, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts at 4 vCPU / 8 GB.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Trigger.dev 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	Trigger.dev, 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	$189 · Free · with limits
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$26 · $20/mo	$799 · Free · 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	$9,694 · Hobby · 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	$2,935 · Pro + 800 extra concurrency (self-serve max) · with limits
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	$6,251 · Pro + 800 extra concurrency (self-serve max) · with limits

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.

Trigger.dev: Trigger.dev bills per second for the machine preset while a run executes, plus $0.000025 per run, and does not bill time spent waiting or paused. Plans are Free with $5 of monthly credit, Hobby at $10 and Pro at $50 with the same amount in usage included, and Pro adds 50 concurrent runs for $10 a month each. The scenarios assume a machine that is busy the whole time, which is the most a Trigger.dev run can cost.

Limits in those scenarios

Trigger.dev is marked as not fitting every scenario because it is a job platform, not a machine: a run has no shell, no inbound ports, no Docker inside and a 10 GB disk that lasts one run. Its concurrency is counted per environment, 20 on Free, 50 on Hobby and 200 on Pro in production, and Pro can buy up to 800 more in the dashboard before review, so 1,000 runs at once is the self-serve ceiling. On bochka the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000-job burst gets queued at 90 starts a minute and needs more starts per day than the $2,000 plan allows.

Scenario	bochka	Trigger.dev
One coding agent, workdays	None that bite	adjacent product, not a like-for-like sandbox different kind of product: batch / job platform disk beyond 10 GiB: price unknown egress price not published
One agent that never stops	None that bite	adjacent product, not a like-for-like sandbox different kind of product: batch / job platform disk beyond 10 GiB: price unknown egress price not published
50 agents in parallel	None that bite	adjacent product, not a like-for-like sandbox missing Docker inside different kind of product: batch / job platform disk beyond 10 GiB: price unknown
Sandboxes for your users	None that bite	adjacent product, not a like-for-like sandbox different kind of product: batch / job platform egress price not published
1,000 short jobs at once	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)	adjacent product, not a like-for-like sandbox different kind of product: batch / job platform egress price not published

Which one should you use?

Use Trigger.dev when

you are building background jobs or chat agents in TypeScript and want retries, queues, schedules and free waits handled for you, or need to self-host the stack.

Durable workflows, not just machines. Useful if you are building background jobs: retries, queues, schedules and waits that cost nothing come built in.
Pay only while code runs. Good for agents that mostly wait: a chat agent sleeps between messages and wakes on the exact line it stopped on.
Open source and US regions. Useful if you must self-host or run in the US: the stack is Apache 2.0 and runs execute in a region you pick.

Use bochka when

your agents need a real computer: installing tools, running Docker and databases, serving what they build on open ports, keeping files between sessions, and running coding agents you drive from outside.

A whole machine, with Docker inside. Coding agents decide what to install while they work. On Trigger.dev that means a redeploy for each new tool, and there is no documented way to run Docker or a test database inside a run.
A machine you can reach and keep. An agent that builds an app needs to serve it so you, a test or a user can open it. On Trigger.dev you would copy the result to other hosting, and each new run starts without the last run's files.
Coding agents built in, keys kept out. Running Claude Code on Trigger.dev means writing and maintaining the task that installs, starts and streams it, with a real API key sitting in the run's environment where agent-written code can read it.

Questions people ask

Is Trigger.dev a sandbox?

Not in the usual sense. It runs TypeScript tasks you deploy, each in an isolated container, and adds retries, queues and waits. You cannot log into a run, open a port on it or run Docker inside it, which is what a sandbox like bochka is for.

Can I run Claude Code on Trigger.dev?

You can run the Claude Agent SDK, the library behind Claude Code, inside a task you write, as Trigger.dev's own guide shows; you wire up its files, tools and output streams yourself. On bochka, Claude Code, Codex and OpenCode are already inside each sandbox, and you drive them with a prompt, steer and events API.

Is bochka cheaper than Trigger.dev?

For machines that stay busy, yes: one coding agent on workdays comes to $20 a month on bochka and $189 on Trigger.dev, and 50 agents in parallel come to $317 versus $9,694. Trigger.dev bills nothing while a run waits, so a task that mostly sleeps can cost much less than these numbers.

Can Trigger.dev and bochka work together?

Yes. A common split is to use Trigger.dev for the schedule, retries and queue, and have a task call bochka's API to start a sandbox and an agent for the heavy work. The task waits for free while the bochka sandbox does the building.

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. On Trigger.dev you choose the region a run executes in, for example eu-central-1, and its docs say this does not change where payloads, outputs and logs are stored.

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. Trigger.dev says it is SOC 2 Type II compliant and offers a HIPAA BAA as a paid add-on.

Start a sandbox

Install the CLI, then run bochka new.

Product preview