boat vs Volcano Engine AgentKit
AgentKit is ByteDance's agent platform on Volcano Engine, and its sandboxes are containers in mainland China that stop after 24 hours. boat gives each agent a full VM in the EU with Docker, a disk that persists and no session cap on paid plans.
Where boat stands out
A full VM, not a container
Every boat sandbox is a VM with its own kernel, and it comes with root, systemd, Docker and /dev/kvm. AgentKit's docs describe each instance as a container started from an image, and they document no Docker or nested virtualization inside it.
A machine that keeps running
boat has no session cap on paid plans. The disk is saved every minute and when you stop, and you can fork a running sandbox. An AgentKit instance ends after 24 hours (7 days only through an account manager), and an ended instance comes back only by restoring a snapshot into a new one.
Agents you drive from outside, keys kept out
Claude Code, Codex and five 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 that covers model providers and any HTTPS API, and a credential can switch to another account when credits run out.
The companies and products
boat
boat.dev 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
Volcano Engine AgentKit
AgentKit is Volcano Engine's platform for building and running AI agents, and its Sandbox tool gives each agent an isolated place to run code, a browser or a desktop.
AgentKit is a whole agent stack: a runtime that hosts your agent app, a gateway for models and MCP tools, memory, knowledge bases, skills and evals. The sandbox part runs on veFaaS, Volcano Engine's serverless platform, where each instance is a container started from an image such as Code, Browser, Computer or All-in-One, and it speaks the E2B API. It is built for teams in mainland China that build agents on ByteDance's cloud and models.
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 | boat: price rank | Volcano Engine AgentKit: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, long builds and a disk that stays; AgentKit sandboxes have no documented Docker and end after 24 hours. | 3rd cheapest of 367 $634 a month | 202nd of 367, with limits $2,336 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month outlasts AgentKit's 24-hour instance lifetime, so it has to be snapshotted and restored into a new instance every day. | 5th cheapest of 366 $657 a month | 49th of 366, with limits $5,036 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month AgentKit fits short code runs well: it bills per second only while an instance lives, and its public images are warmed for fast starts. | 186th of 345, with limits $2,000 a month | 33rd cheapest of 345 $344 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month AgentKit can give each user a container instance behind its API gateway with API key or OAuth auth, but only in mainland China; boat gives each user a full VM with hosting built in. | Cheapest of 361 $209 a month | 88th of 361, with limits $795 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month veFaaS sandboxes are built for RL rollouts, with ready R2E-Gym, SWE-bench and WebArena images and veRL integration. | 34th of 360, with limits $2,000 a month | 58th of 360, with limits $3,273 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 | 132nd of 364, with limits $659 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 | 67th cheapest of 377 $516 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs to run for weeks with SSH; AgentKit has a console Webshell and no SSH, and instances end after 24 hours. | 18th cheapest of 368 $26 a month | 258th of 368, with limits $101 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both have a Linux desktop for computer use; boat streams it at 60fps and can be embedded in your app. | 6th cheapest of 369 $200 a month | 24th cheapest of 369 $1,062 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 | 72nd of 367, with limits $362 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 | 61st cheapest of 346 $573 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 | 131st of 338, with limits $3,863 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Red teaming often needs Docker and root inside the target; boat has both, and AgentKit documents neither. | 2nd cheapest of 360 $200 a month | 65th of 360, with limits $356 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 | boat | Volcano Engine AgentKit |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Isolated container runtime started from an image; the isolation layer is not named |
| Docker, root and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | None documented; the E2B-compatible API covers commands, files, code and volumes |
| Session length | No cap on paid plans; you set the time to live | 24 hours at most, 8 hours by default; up to 7 days through your account manager |
| Saving the disk | Snapshots every minute and on stop; a stopped sandbox costs nothing and keeps its disk | Opt-in snapshot when an instance expires, plus manual snapshots; each manual snapshot restores once, into a new instance |
| Pause and wake | Stop keeps the disk; you start the sandbox again by API | Pause keeps files but not memory (beta, turned on by ticket); connecting to a paused sandbox resumes it |
| Fork | Fork a running sandbox with its disk | No fork or clone in the documented API |
| Machine size | Up to 16 vCPU / 32 GB on the $100 plan and above | 2 to 16 vCPU and up to 128 GiB RAM, at 1:2, 1:4 or 1:8 per vCPU |
| Desktop and browser | 60fps desktop and Chromium, computer use and browser control, embeddable stream | Browser, Computer (Linux desktop) and All-in-One images, plus a Computer Use Agent template |
| Coding agents | Claude Code, Codex and five other agents preinstalled, with a prompt, steer and events API | Code Sandbox ships Codex; the AgentKit CLI starts it as a shell command; ArkClaw and Hermes agents answer through chat |
| 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 | Model gateway hands agents a Proxy API Key for model calls only, with a backup model when quota runs out; the gateway is billed |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH | HTTPS through API gateway domains with API key or OAuth JWT auth; Webshell; no SSH or public IP |
| Private network | Open internet, no provider-side allowlist | Optional VPC mode with security groups and your own NAT for egress; IP-level, no domain rules |
| Agent platform around the sandbox | Sandboxes with agents, hosting and credentials built in; no agent hosting runtime or MCP gateway | Agent runtime, MCP gateway, memory, knowledge bases, skills and evals; a sandbox can be published as an MCP service |
| Regions | EU only (Germany, Finland, France), with EU data residency and zero data retention | Mainland China only (Beijing, Shanghai) |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | Not published |
Every feature Battleships tracks (43)
| Feature | boat | Volcano Engine AgentKit |
|---|---|---|
| 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 | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| 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 | No |
| 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 | Yes |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | Not published |
| 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 | No |
| Audit logs | No | Not published |
| SSO | No | Not published |
| SOC 2 | No | Not published |
| HIPAA | No | Not published |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for AgentKit. boat did 26.69 runs per second on the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, but AgentKit was not part of that benchmark, so we can't say which is faster.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Volcano Engine AgentKit 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 | boat, a month | Volcano Engine AgentKit, 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 | $25 · 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 | $101 · 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,162 · 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 | $362 · Pay as you go · 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 | $659 · Pay as you go · with limits |
boat: 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.
Volcano Engine AgentKit: AgentKit bills in CNY for the vCPU and memory size you set, per second while an instance lives, plus 0.8 CNY per GB of public traffic, paid from a prepaid balance. List prices include Chinese VAT, and the model gateway and agent runtime have their own gateway fees.
Limits in those scenarios
Every AgentKit scenario is marked as not fitting because the service runs only in mainland China, on a Volcano Engine account under local rules. The 24-hour lifetime rules out the always-on agent, and no documented Docker rules out the 50-agent fleet. Each sandbox template allows 100 instances at once; you can ask for more through the quota center. boat has no session cap, but at 1,000 short jobs at once the $2,000 plan queues starts and runs out of daily starts.
| Scenario | boat | Volcano Engine AgentKit |
|---|---|---|
| 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 Volcano Engine AgentKit when
you build agents for users in mainland China on ByteDance's cloud and want the runtime, gateway, memory and short-lived sandboxes in one place.
- A whole agent platform in mainland China. Useful for teams building agents on Volcano Engine: runtime, MCP gateway, memory, knowledge bases, skills and evals come in one console.
- Pay only while short jobs run. Good for bursts of short code runs: billing is per second while an instance lives, with no plan fee.
- Private network and bigger memory. Fits jobs that must stay inside a private network, or need up to 128 GiB of RAM on one instance.
Use boat when
your agents do real work for hours or weeks: installs, builds, Docker, emulators and a browser on a full VM in the EU, with coding agents and a credentials proxy built in.
- A full VM, not a container. Coding agents run docker compose, build images and start emulators. In an AgentKit instance none of that is documented, so those jobs need a different machine, and a container shares its host's kernel.
- A machine that keeps running. An agent that works across days on AgentKit has to be snapshotted and restored into a new instance before each lifetime runs out. Running processes are lost each time, and your code has to handle the hand-off.
- Agents you drive from outside, keys kept out. AgentKit's Codex is started as a shell command, so you parse terminal output yourself. Its Proxy API Key covers model calls only, so other secrets still sit inside the machine the agent controls.
Questions people ask
Is boat cheaper than Volcano Engine AgentKit?
In four of the five scenarios we priced, yes: one coding agent on workdays comes to $20 a month on boat and $25 on AgentKit, one agent running all month to $26 against $101, and 50 agents in parallel to $317 against $1,162. For 1,000 short jobs at once AgentKit comes to $659 against $2,000, though neither fits without higher limits.
Are AgentKit sandboxes VMs or containers?
Volcano Engine's veFaaS docs call each sandbox instance a secure, isolated container runtime started from an image, and they do not name the isolation layer. Every boat sandbox is a full VM with its own kernel.
How long can an AgentKit sandbox run?
Up to 24 hours per instance, with 8 hours as the default; you can ask your account manager for up to 7 days. After that, you can restore a snapshot into a new instance. boat has no session cap on paid plans.
Can I run Docker in an AgentKit sandbox?
AgentKit and veFaaS do not document Docker or /dev/kvm inside a sandbox; the API covers commands, files, code and volumes. boat runs Docker and nested virtualization on every machine.
Can I use AgentKit outside China?
AgentKit on Volcano Engine runs in Beijing and Shanghai and needs a Volcano Engine account. boat runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial