Kernel vs Browserless
Kernel gives each agent a Chromium browser on its own small unikernel, with SSH, free standby and stealth proxies. Browserless gives you managed headless Chrome, Firefox and WebKit sessions of up to 60 minutes, driven with Puppeteer, Playwright or BrowserQL, and a Docker image you can run yourself.
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.
Browserless
Browserless calls itself a cloud browser automation platform: managed headless browsers you connect to with one line of code.
You point existing Puppeteer, Playwright or Selenium code at a Browserless WebSocket URL, or use BrowserQL, its GraphQL language with stealth and CAPTCHA solving, REST endpoints for screenshots, PDFs and scraping, and an MCP server. Sessions are short (2 to 60 minutes by plan), and only the browser profile can be kept between them. It is a browser product, not a general sandbox: you get a browser, not a shell or root on the machine, so this page compares where the two overlap, which is agents that browse.
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 | Browserless: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent needs a shell, Docker and a disk; Kernel documents no Docker and keeps no disk, and Browserless gives no shell at all, so builds and tests fit boat. | 98th of 367, with limits $873 a month | 170th of 367, with limits $1,771 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that works all month needs files that stay; Kernel keeps only cookies and storage in a profile, and Browserless hits its 60-minute session cap and keeps only a browser profile. | 203rd of 366, with limits $2,033 a month | 297th of 366, with limits $6,170 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 | 267th of 345, with limits $350 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 more than Kernel's Start-Up limit of 150 browsers and Browserless's Scale annual limit of 100, and each user gets a browser rather than a machine. | 228th of 361, with limits $768 a month | 264th of 361, with limits $1,490 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 | 279th of 360, with limits $8,600 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 | 247th of 364, with limits $350 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 | 241st of 377, with limits $140 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box has to keep files and processes; a Kernel browser can stand by for free but is deleted after its timeout, and a Browserless session ends within 60 minutes, so this fits boat. | 144th of 368, with limits $33 a month | 336th of 368, with limits $350 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 headful Live View and a computer controls API, while Browserless is a compromise with headless browsers and live hand-off URLs; boat streams a 60fps desktop where an agent can use any Linux app. | 38th cheapest of 369 $1,878 a month | 141st of 369, with limits $350 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 fit and sit close together: Kernel gives a Chromium over CDP with stealth built in, Browserless gives Chrome, Firefox or WebKit over Puppeteer, Playwright or BrowserQL, and boat adds a full VM where the agent can also run code. | 21st cheapest of 367 $366 a month | 19th cheapest of 367 $350 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 fit at startup scale; Browserless also has REST endpoints for screenshots, PDFs and scraping, so some pages need no script at all. | 45th cheapest of 346 $443 a month | 47th cheapest of 346 $478 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 Kernel fits mass scraping better on cost, since its proxies are not charged, at $6,000 a month against $17,150 for Browserless, whose proxy traffic and CAPTCHA solves use plan units; boat uses datacenter IPs and solves no CAPTCHAs. | 4th of 338, with limits $6,000 a month | 20th of 338, with limits $17,150 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 | 61st of 360, with limits $293 a month | 247th of 360, with limits $350 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 | Browserless | boat |
|---|---|---|---|
| Kind of product | A managed Chromium per session on its own unikernel, with an app runtime for your code | Managed headless Chrome, Firefox and WebKit, plus BrowserQL, REST APIs and an MCP server | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | Every browser on its own Unikraft-based unikernel | Browsers in Docker containers that share the host kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Shell and root | SSH into the browser VM, and process exec with an as_root option | No shell or SSH; you reach the browser over CDP, BrowserQL or REST | SSH and root on the whole machine, any package, any process |
| Docker and nested virtualization | A single-purpose unikernel; no container runtime or /dev/kvm documented | Not offered in a session; you can self-host the Browserless Docker image | Docker, systemd and /dev/kvm on every machine |
| Machine size | 1 GB headless, 8 or 16 GB headful; vCPU count not published | vCPU and RAM behind a session not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| Session length | Stays alive while something drives it; deleted after an idle timeout of 60 seconds by default, up to 72 hours | 2 minutes on Free, 15 on Prototyping, 30 on Starter, 60 on Scale | No cap on paid plans; you set the time to live |
| Idle and wake | Standby after 5 seconds idle with a memory snapshot and no usage charge | Billed per 30-second unit while connected; a reconnect starts a new browser process | Stop and resume by API; resume reboots from disk (no memory snapshots) |
| Files after a session | The browser is deleted after its timeout; profiles keep cookies, storage and browser state | Persisted sessions keep cookies, localStorage and cache for 1 to 90 days by plan | The disk persists, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Bot detection | Stealth mode with an ISP proxy and a CAPTCHA solver; residential proxies; proxies not charged | BrowserQL stealth with fingerprint mitigations, CAPTCHA solving, residential and datacenter proxies billed in units | Datacenter IPs and Chromium; no CAPTCHA solving |
| Computer use | Headful Chromium with Live View, a computer controls API and session replays | Headless browsers, live URLs that hand a session to a person, and computer-use integrations | 60fps desktop and Chromium, computer use on any app, embeddable stream |
| Reaching the machine | No inbound ports; tokenized CDP and Live View URLs, and SSH port forwarding | Fixed regional WebSocket and HTTPS endpoints; no ports to host on | HTTPS URLs for up to 50 ports, token-protected; raw TCP; own IP |
| Coding agents | A Claude Agent SDK app template that installs Claude Code when you deploy your app | Its own managed browser agent (Agent Run API, beta), up to 15 minutes and 60 steps per turn | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Self-hosting | Hosted only; browser images are public on GitHub | Run the open source Docker image yourself; commercial use needs a license | Hosted only |
| Regions | us-east, eu-west and ap-southeast; region choice from the Start-Up plan | San Francisco, London and Amsterdam; New York on private fleets | EU only: Germany, Finland and France |
Every feature Battleships tracks (43)
| Feature | Kernel | Browserless | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | No | No | 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 | Not published | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | Not published | Not published | 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 | Yes | No |
| Windows | No | No | No |
| Arm64 | Not published | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | Yes | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | 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 Browserless was in StarSling's public CPU benchmark, and neither publishes the vCPUs behind a browser, so there is nothing to set against boat's 26.69 runs per second at 4 vCPU / 8 GB. Kernel does publish 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 Browserless 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 | Browserless, 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 | $350 · Scale annual · 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 | $350 · Scale annual · 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 | $1,026 · Scale annual · 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 | $410 · Scale annual · 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 | $1,400 · Scale annual · 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 less 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.
Browserless: Browserless bills in units: one unit is up to 30 seconds of a connected browser, and a reconnect starts a new block. Plans include 20,000, 180,000 or 500,000 units a month, proxy traffic and CAPTCHA solves use the same units, and annual billing is 30% lower and adds concurrency.
Browserless: 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.
Limits in those scenarios
None of the Kernel or Browserless prices in the table is a 4 vCPU / 8 GB machine with a disk that stays: both sell a browser of unpublished size. Browserless's 60-minute session cap on Scale is why its workday agent, always-on agent and 50-agent fleet do not fit, while Kernel's free plan prices the workday agent at $5 but keeps no files. Concurrency is the other limit: 150 browsers at once on Kernel Start-Up and 100 on Browserless Scale annual, so 300 sandboxes for your users and 1,000 short jobs at once need Enterprise on both. On boat, the 1,000-job burst is the one that does not fit: bursts above 90 starts a minute are queued.
| Scenario | Kernel | Browserless | 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
your agent needs one Chromium that can sit idle for free, stealth scraping with proxies included, SSH into the browser VM, or browsers in Asia.
- Free standby with pages kept. Useful if your agents wait between steps: a Kernel browser stops charging after 5 seconds idle and comes back with its pages loaded.
- Stealth with proxies included. Useful for scraping sites that block bots at volume: stealth mode, ISP and residential proxies and a CAPTCHA solver, with proxies not charged.
- Long sessions and a shell. Useful for tasks longer than an hour: a Kernel browser runs while it is driven, and you can SSH into its VM.
Use Browserless when
you want to run your existing Puppeteer, Playwright or Selenium scripts on Chrome, Firefox or WebKit, use REST screenshots and PDFs, or self-host the browsers in your own network.
- Run it on your own machines. Useful if browsers must stay inside your network: the Browserless Docker image is open source and can be self-hosted, with a license for commercial use.
- Three browser engines, your existing scripts. Useful if you test across browsers: point Puppeteer, Playwright or Selenium code at Chrome, Firefox or WebKit with one URL change.
- Ready-made web endpoints. Useful when the job is only the web: REST calls return screenshots, PDFs and scraped content, and a live URL hands a login to a person.
Where boat fits
Kernel and Browserless both sell a browser, not a machine. If what you are really running is agents that browse and then also install packages, build in Docker or run a dev server, look at boat: each sandbox is a full Linux VM with root, a disk that stays, a 60fps desktop with Chromium and coding agents built in. Keep Kernel or Browserless next to it for stealth scraping behind CAPTCHAs, which boat does not do.
A whole machine, with Docker
Kernel's unikernel documents no container runtime, and Browserless gives no shell at all. An agent that has to clone a repo or run docker compose needs a second machine next to either, and you wire files between the two yourself.
Files that stay, and a fork
A Kernel browser is deleted after its timeout and a Browserless session ends within 60 minutes; both keep only cookies and storage. boat keeps the disk with snapshots every minute, and can fork a running sandbox to try two paths.
Agents driven from outside, keys kept outside
Kernel's vaults fill logins into the page, where page scripts can read them, and Browserless's beta agent stops at 15 minutes a turn. boat drives coding agents inside from outside, and its credentials proxy keeps real API keys out of the sandbox.
Use boat when your agent browses and also works: installs, builds, Docker and dev servers on a full VM that keeps its disk and runs as long as the task takes, with a 60fps desktop and coding agents built in. Compare it one to one: boat vs Kernel and boat vs Browserless.
Questions people ask
Is Kernel cheaper than Browserless?
In most of the table, yes: one agent running all month comes to $34 on Kernel against $350 on Browserless, 50 agents in parallel to $625 against $1,026, and 1,000 short jobs at once to $747 against $1,400. Sandboxes for your users are close, at $420 against $410. None of these fits fully, since both are browser sessions, not 4 vCPU / 8 GB machines; boat comes to $26, $317 and $200 where it fits.
Which is faster, Kernel or Browserless?
There is no comparable number. Neither was in StarSling's public CPU benchmark and neither publishes the vCPUs behind a browser. Kernel publishes cold starts under 20 ms for its unikernels.
Can Kernel or Browserless run Docker?
Not in a hosted session. A Kernel browser is a single-purpose unikernel with SSH and process exec but no documented container runtime, and a Browserless session gives a browser only, though you can run its Docker image on your own server. Every boat sandbox has root, Docker, systemd and /dev/kvm.
How long can a session run?
A Kernel browser stays alive while something drives it, and is deleted after an idle timeout of 60 seconds by default, up to 72 hours. Browserless caps sessions at 2, 15, 30 or 60 minutes by plan, custom on Enterprise. boat has no session cap on paid plans.
Which is better for scraping sites that block bots?
Both have stealth, CAPTCHA solving and residential proxies. Kernel does not charge for proxies, while Browserless proxy traffic and CAPTCHA solves use plan units, so for mass scraping Kernel comes to $6,000 a month against $17,150. boat uses datacenter IPs and solves no CAPTCHAs.
Can I self-host Kernel or Browserless?
Browserless, yes: its core is open source on GitHub and runs with one docker run, with a paid license for commercial use. Kernel is hosted only, though its browser images are public on GitHub. boat is hosted only.
Try boat
Install the CLI, then run boat new.
7-day free trial