Kernel vs Anchor Browser
Both rent your agent a cloud Chromium it drives over CDP. Kernel is browser infrastructure for developers, with unikernel browsers that sleep for free and a shell inside, while Anchor Browser adds managed logins with MFA and hosted agents that take a task in plain words.
The companies and products
Kernel
Kernel is browser infrastructure for web agents and automations: you create cloud Chromium browsers from its API and drive them over CDP.
Each Kernel browser is Chromium on its own Unikraft-based unikernel, headless (1 GB) or headful (8 or 16 GB) with Live View and a computer controls API. Around it Kernel sells stealth mode with proxies and a CAPTCHA solver, saved browser profiles, managed logins, session replays and an app runtime for your agent code. It is a different kind of product from boat: a managed browser, not a general sandbox, so this page compares where the two overlap, which is agents that use a browser.
Anchor Browser
Anchor Browser is cloud browser infrastructure for AI agents: managed Chromium sessions you control over CDP or a REST API, plus a hosted browser agent.
Anchor Browser is a different kind of product from boat. Each session is a headful Chromium in its own VM that is erased when the session ends, and you drive it with Playwright or Puppeteer, with mouse and keyboard calls, or by sending a task in plain words to its hosted agent. It adds managed logins with MFA, residential proxies, stealth and CAPTCHA solving, and its own docs tell you to run your agent's code in a separate sandbox and connect to the browser over CDP.
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. “38th cheapest of 369” means 37 of the other 368 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 | Kernel: price rank | Anchor Browser: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs a shell, Docker and a place to build; Kernel documents no container runtime and Anchor's own docs send code to a separate sandbox. | 98th of 367, with limits $873 a month | 180th of 367, with limits $2,000 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Anchor does better than Kernel here (rank 71 against 203), since its volumes keep files between sessions, but neither gives an all-month assistant a machine whose disk stays. | 203rd of 366, with limits $2,033 a month | 71st of 366, with limits $1,845 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 | 266th of 345, with limits $347 a month | 325th of 345, with limits $2,171 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 300 sandboxes at once is past both self-serve limits (150 on Kernel Start-Up, 200 on Anchor Growth), and each user gets a browser rather than a machine. | 228th of 361, with limits $768 a month | 283rd of 361, with limits $2,000 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 | 246th of 360, with limits $3,133 a month | 298th of 360, with limits $12,510 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 | 252nd of 364, with limits $390 a month | 357th of 364, with limits $2,000 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 | 259th of 377, with limits $222 a month | 284th of 377, with limits $500 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 144th of 368, with limits $33 a month | 222nd of 368, with limits $42 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 Kernel fits computer use with Live View and a computer controls API, while Anchor's mouse and keyboard calls stay inside the browser; boat streams a whole Linux desktop at 60fps. | 38th cheapest of 369 $1,878 a month | 173rd of 369, with limits $500 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 Both are built for this: Kernel ranks 21st and Anchor Browser ranks 28th, while boat ranks 7th because its Chromium sits on a full VM where the agent can also run code. | 21st cheapest of 367 $366 a month | 28th cheapest of 367 $560 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 Both handle startup-scale bots well and sit close together, with Kernel at rank 45 and Anchor at rank 50; boat also fits and keeps each bot's files on a disk. | 45th cheapest of 346 $443 a month | 50th cheapest of 346 $500 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 This is where both shine: Kernel ranks 4th and Anchor Browser ranks 5th, thanks to stealth, residential proxies and CAPTCHA solving that boat does not offer. | 4th of 338, with limits $6,000 a month | 5th of 338, with limits $6,175 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 Kernel's cheap headless browsers make it the better of the two for many parallel runs (rank 61 against 334), though neither offers a shell like boat's VM. | 61st of 360, with limits $293 a month | 334th of 360, with limits $2,000 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 | Can't run it | 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 | Kernel | Anchor Browser | boat |
|---|---|---|---|
| What one session is | Chromium on its own Unikraft-based unikernel, headless or headful | A headful Chromium in its own VM, erased when the session ends | A full Linux VM with its own kernel and root, with a desktop and Chromium inside |
| Machine size | 1 GB headless, 8 or 16 GB headful; vCPU count not published | CPU and memory per browser not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| Shell, code and Docker | SSH into the browser VM and process exec with an as_root option; no container runtime documented | No shell; from Growth you can run TypeScript snippets against the page | SSH, root, any language, Docker, systemd and /dev/kvm on every machine |
| Files after a session | The browser is deleted after its timeout; profiles keep cookies, storage and browser state | The VM is erased; profiles keep cookies, local storage and cache, and up to 10 volumes keep files | The whole disk is saved every minute and on stop; a stopped sandbox costs nothing |
| Idle time | Standby after 5 seconds idle with a memory snapshot and no usage charge; a new connection picks it up | The session ends 5 minutes after the last connection closes by default; you can turn that off | Stop and resume by API; resume reboots from disk (no memory snapshots) |
| Session length | Stays alive while something drives it; deleted after an idle timeout of up to 72 hours | 180 minutes by default, with no upper limit if you raise it | No cap on paid plans; a stopped sandbox keeps its disk |
| Browsers at once | 5, 10 and 150 on Developer, Hobbyist and Start-Up; custom on Enterprise | 5, 25, 50 and 200 on Free, Starter, Team and Growth; 500+ on Enterprise | Fits the 300-at-once user sandbox scenario; bursts above 90 starts a minute are queued |
| Fork | No fork; browser pools keep fresh browsers warm | No fork or snapshots | Fork a running sandbox into a copy |
| Stealth and proxies | Stealth mode with an ISP proxy and CAPTCHA solver; datacenter, ISP, residential and mobile proxies not charged | CAPTCHA solving from Starter, full stealth on Growth; residential proxies with city targeting at $8 per GB | Chromium on datacenter IPs; no CAPTCHA solving or managed proxies |
| Logging in to sites | Managed auth keeps sign-ins in profiles; vaults fill logins into forms | Managed identities with MFA keep logins across sessions, from Starter | Your agent logs in itself; AI credentials switch to another account when credits run out |
| Agents | An app runtime for your agent code, with a Claude Agent SDK template | Hosted browser agents that take a task in plain words, with human-in-the-loop, webhooks and a hosted MCP server | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Keeping secrets from the agent | Vaults fill logins into the page, where page scripts can read them | Secret values are hidden from the model and typed into the page | Credentials proxy: real keys never enter the sandbox, for model providers and any HTTPS API |
| Reaching the machine | No inbound ports; tokenized CDP and Live View URLs, and SSH port forwarding | No ports of your own; only the CDP socket and the live view URL | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Regions | us-east, eu-west and ap-southeast; region choice from Start-Up | US by default; Frankfurt, Asia and Australia on Growth; any region, your own cloud or on-premise on Enterprise | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Kernel | Anchor Browser | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | No | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | No | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | No | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | Not published | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | Not published | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable measurement for either. Neither Kernel nor Anchor Browser is in StarSling's CPU benchmark, and neither publishes how many vCPUs a browser gets, so no speed ratio is possible. boat scored 26.69 runs per second on the Node.js test at 4 vCPU / 8 GB, and Kernel publishes cold starts under 20 ms for its unikernels.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Kernel and Anchor Browser 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 | Kernel, a month | Anchor Browser, a month | boat, 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 | $5 · Free / Developer · with limits | $7 · Free · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $34 · Free / Developer · with limits | $42 · Free · 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 | $625 · Start-Up · with limits | $500 · Team · with limits | $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 | $420 · Start-Up · with limits | $2,000 · Growth · with limits | $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 | $747 · Start-Up · with limits | $2,510 · Growth · with limits | $2,000 · $2000/mo · with limits |
Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active, so a 1 GB headless browser costs far less per hour than an 8 GB headful one. Standby and proxies are free, and plans of $0, $30 and $200 a month include $5, $10 and $50 of usage.
Anchor Browser: Anchor bills $0.05 per browser-hour plus $0.01 for each browser created, paid from credits worth $1 each that the plan fee buys. Traffic is extra: $8 per GB through Anchor's proxy or $0.20 per GB direct, and AI tasks are priced per step.
Anchor Browser: Plans start at $20 a month and the whole fee is usage credit, spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
None of the five scenarios fits Kernel or Anchor Browser as written, because each asks for a general machine and both sell a browser of a size they do not publish, with no disk that stays. Kernel caps browsers at 150 at once on Start-Up and Anchor at 200 on Growth, so 300 sandboxes for your users and 1,000 short jobs at once need Enterprise on either. Anchor sessions also end after 180 minutes and 5 idle minutes unless you raise those limits. boat fits four scenarios; at 1,000 short jobs at once its top plan queues the starts.
| Scenario | Kernel | Anchor Browser | boat |
|---|---|---|---|
| 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 Kernel when
you want browser infrastructure you build on: cheap headless browsers that sleep for free, proxies included, SSH into the browser, and regions in the US, EU and Asia from the Start-Up plan.
- Idle browsers cost nothing. For agents that pause between steps: a Kernel browser goes to standby after 5 idle seconds, stops charging, and wakes with its pages loaded.
- Proxies included. For scraping at volume: Kernel's datacenter, ISP, residential and mobile proxies are not charged, while Anchor bills traffic through its proxy per GB.
- A shell inside the browser. For teams that need to poke at the browser machine: Kernel offers SSH and process exec as root, which Anchor sessions do not.
Use Anchor Browser when
you want the browser work done for you: managed logins with MFA, hosted agents that take a task in plain words, city-targeted proxies, or your own cloud on Enterprise.
- Hosted browser agents. For teams that want to send a task and get a result: pick a computer-use model, pause for a human, and get webhooks.
- Logins with MFA and files that stay. For agents working inside web apps: managed identities stay logged in with MFA, and up to 10 volumes keep files between sessions.
- More browsers and your own cloud. For large fleets: 200 browsers at once on Growth, 500+ on Enterprise, and your own cloud or on-premise if you need it.
Where boat fits
Kernel and Anchor Browser both sell a browser, and boat is not a stealth browser service. If what you are really running is agents that browse and then do work, such as installing tools, building code or serving an app, boat gives each one a whole Linux VM with Chromium and a 60fps desktop inside. You can also keep a Kernel or Anchor browser for the sites with hard bot checks and drive it from a boat sandbox over CDP.
A machine around the browser
Kernel's unikernel documents no container runtime, and Anchor has no shell and tells you to run code in a separate sandbox. Either way you pay for and wire up a second service. boat has root, Docker, systemd and /dev/kvm next to the browser.
Work that is still there tomorrow
A Kernel browser is deleted after its timeout and an Anchor VM is erased each session, so tools and downloads start over. boat saves the whole disk every minute and on stop, and can fork a running sandbox.
Keys the agent cannot read
Kernel's vaults and Anchor's secrets are both typed into the page, where page scripts can reach them. boat's credentials proxy keeps real keys outside the sandbox for model providers and any HTTPS API, and drives coding agents inside from outside.
Use boat when your agent does more than browse: it needs a shell, Docker, a desktop or a server next to Chromium, and it has to keep its files between runs. Compare it one to one: boat vs Kernel and boat vs Anchor Browser.
Questions people ask
Is Kernel cheaper than Anchor Browser?
In most of the table, yes: one agent running all month is $34 on Kernel against $42 on Anchor, and 300 sandboxes for your users $420 against $2,000. Anchor is lower for 50 agents in parallel, $500 against $625. Neither is a general machine in these scenarios, and Anchor bills proxy traffic and AI steps on top.
Which is faster, Kernel or Anchor Browser?
There is no fair measurement. Neither is in the CPU benchmark and neither publishes the vCPUs behind a browser. Kernel does publish cold starts under 20 ms for its unikernels.
Can Kernel or Anchor Browser run Docker?
No. Kernel's browser is a single-purpose unikernel with no container runtime documented, though you can SSH in and run commands. Anchor gives no shell at all and its docs say to run agent code in a separate sandbox. A boat sandbox is a full VM with Docker, systemd and /dev/kvm.
Which is better at getting past bot checks?
Both are built for it. Kernel's stealth mode adds an ISP proxy and a CAPTCHA solver, and its proxies are not charged. Anchor solves CAPTCHAs from Starter, runs full stealth on Growth, gives unique fingerprints on Enterprise and targets residential proxies down to the city.
How long can a session run?
A Kernel browser stays alive while something drives it and is deleted after an idle timeout you can set up to 72 hours. An Anchor session ends after 180 minutes by default, and you can raise that with no upper limit. On boat paid plans there is no session cap and a stopped sandbox keeps its disk.
Can I use Kernel or Anchor Browser from a boat sandbox?
Yes. Both are driven over CDP and an API, so an agent on a boat sandbox can open one for the sites with hard bot checks. Its code, files and tools stay on the boat VM, which keeps its disk.
Try boat
Install the CLI, then run boat new.
7-day free trial