Browser Use vs Kernel
Browser Use rents you stealth cloud browsers and a hosted agent you send tasks to, billed per browser-hour. Kernel gives you Chromium on its own unikernel that you drive over CDP or SSH into, billed per GB-second of memory, with free standby when idle.
The companies and products
Browser Use
Browser Use makes the popular open-source browser-agent library and runs Browser Use Cloud, a service of managed browsers and a hosted agent that uses them.
Browser Use Cloud is a different kind of product from bochka: you get a hardened Chromium browser in their cloud that you drive over CDP with Playwright or Puppeteer, or a hosted agent that you send tasks to through an API. It comes with stealth fingerprints, CAPTCHA solving and residential proxies, and you pay per browser-hour. It is built for teams that need many browsers that get past anti-bot checks, not a machine to run their own code on.
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 bochka: a managed browser, not a general sandbox, so this page compares where the two overlap, which is agents that use a browser.
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 | Browser Use: price rank | Kernel: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither is built for a software factory: Browser Use has no shell, Kernel keeps no disk and documents no Docker, and bochka ranks 3rd with a full VM. | 48th of 367, with limits $301 a month | 98th of 367, with limits $873 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that runs all month hits Browser Use's 4-hour stop and Kernel's deleted browser files; bochka ranks 5th with a machine that keeps going and keeps its disk. | 63rd of 366, with limits $750 a month | 203rd of 366, with limits $2,033 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 | 216th of 345, with limits $71 a month | 266th of 345, with limits $347 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 Kernel's Start-Up limit of 150 browsers and needs a $5,000 lifetime spend tier on Browser Use; bochka ranks 1st here. | 199th of 361, with limits $270 a month | 228th of 361, with limits $768 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 | 227th of 360, with limits $1,010 a month | 246th of 360, with limits $3,133 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 | 226th of 364, with limits $90 a month | 252nd of 364, with limits $390 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 | 219th of 377, with limits $64 a month | 259th of 377, with limits $222 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither is a dev box: Kernel ranks 144th and Browser Use 212th, while bochka ranks 18th with SSH, root and a disk that stays. | 212th of 368, with limits $25 a month | 144th of 368, with limits $33 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 agents with Live View and a computer controls API for its browser, Browser Use only shows the browser tab, and bochka streams a full 60fps Linux desktop. | 83rd of 369, with limits $133 a month | 38th cheapest of 369 $1,878 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 browser-use agents; Browser Use ranks 3rd with a hosted agent and stealth on by default, Kernel ranks 21st, and bochka ranks 7th with a full VM around the browser. | 3rd cheapest of 367 $140 a month | 21st cheapest of 367 $366 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 At startup scale Browser Use ranks 14th and Kernel 45th, while bochka ranks 6th by giving each bot a whole machine with a disk that keeps its files. | 14th cheapest of 346 $198 a month | 45th cheapest of 346 $443 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 Both are built for scraping sites with bot checks; Browser Use ranks 1st with residential proxies on by default, Kernel ranks 4th with stealth mode and proxies at no extra charge. | Cheapest of 338 $2,950 a month | 4th of 338, with limits $6,000 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 | 50th of 360, with limits $68 a month | 61st of 360, with limits $293 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 | Browser Use | Kernel | bochka |
|---|---|---|---|
| What you get | A managed Chromium browser over CDP, or a hosted agent you send tasks to | A Chromium browser on its own unikernel, with an app runtime for your code | A full Linux VM with its own kernel and root, with a desktop and Chromium inside |
| Machine size | Not published; you pay per browser-hour | 1 GB headless, 8 or 16 GB headful; vCPU count not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| Shell access | No shell on the machine running the browser | SSH into the browser VM, and process exec with an as_root option | SSH and root on every machine |
| Docker and nested virtualization | No | No container runtime or /dev/kvm documented | Docker, systemd and /dev/kvm on every machine |
| Session length | Agent browsers stop after 4 hours; idle ones are cleaned up after about 20 minutes | No documented cap while driven; deleted after an idle timeout you can set up to 72 hours | No cap on paid plans; you set the time to live |
| State between sessions | Profiles keep cookies and logins; workspaces sync up to 950 MiB of files | Profiles keep cookies, storage and browser state; files go when the browser is deleted | The whole disk is saved every minute and on stop; fork a running sandbox |
| Idle | Billed while the browser runs, rounded up to whole minutes | Standby after 5 seconds idle, memory kept, no usage charge | Stop by API at no cost; resume reboots from disk |
| Live view and desktop | Live view of the browser tab you can embed, plus a recording | Headful Chromium with Live View, a computer controls API and session replays | A full Linux desktop streamed at 60fps, or Chrome alone; embed it, record it |
| Stealth and CAPTCHAs | Hardened Chromium fork, per-session fingerprints, CAPTCHA solving (off in the EU) | Stealth mode with an ISP proxy and a CAPTCHA solver | Chromium on datacenter IPs; no fingerprint rotation or CAPTCHA solving |
| Proxies | Residential proxies in 195+ countries, on by default, billed per GB | ISP, residential and other proxies with no extra charge; bring your own on Start-Up | None managed; you can run your own proxy client inside the VM |
| Agents | Their own hosted browser agent with a choice of models | An app runtime, with a Claude Agent SDK template that installs Claude Code | Seven coding agents preinstalled, with a prompt, steer and events API |
| Keeping secrets from the agent | Secrets typed into the page by alias; the model never sees them | Vaults fill logins into forms, where page scripts can read them | Credentials proxy: real keys never enter the sandbox, for any HTTPS API |
| Hosting | No way to serve your own ports | No inbound ports; tokenized CDP and Live View URLs, and SSH port forwarding | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Regions | US, plus an EU deployment in Frankfurt with fewer features | us-east, eu-west and ap-southeast; region choice from the Start-Up plan | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Browser Use | Kernel | bochka |
|---|---|---|---|
| Full VM (own kernel) | Not published | Yes | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | No | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Not published | Yes | Yes |
| ≥24 h sessions | No | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | 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 | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | Not published | No |
| Self-hosting | Yes | No | No |
| BYOC | No | No | No |
| Open source | Yes | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Yes | Yes |
Performance
There is no comparable measurement for either. Browser Use and Kernel do not publish the vCPUs behind a browser, and neither is in the CPU benchmark. bochka scored 26.69 runs per second on the hpc-sandbox-benchmarks Node.js test at 4 vCPU / 8 GB, and 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. Browser Use and Kernel 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 | Browser Use, a month | Kernel, a month | bochka, 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 | $7 · Pay as you go · with limits | $5 · Free / Developer · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $25 · Pay as you go · with limits | $34 · Free / Developer · 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 | $178 · Spend tier 50 · with limits | $625 · Start-Up · 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 | $150 · Spend tier 500 · with limits | $420 · Start-Up · 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 | $210 · Spend tier 1000 · with limits | $747 · Start-Up · with limits | $2,000 · $2000/mo · with limits |
Browser Use: Browser Use bills $0.02 per browser-hour, rounded up to whole minutes, from prepaid credits that never expire. Proxy traffic is $5 per GB (the proxy is on by default) or $0.20 per GB direct, and agent runs add model tokens plus a 20% fee.
Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active, so an 8 GB headful browser costs eight times a 1 GB headless one. Standby and proxies are free, and plans of $0, $30 and $200 a month include $5, $10 and $50 of usage.
Kernel: 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.
Limits in those scenarios
No scenario fits Browser Use or Kernel as written, because each asks for a general machine and both sell a browser of a size they do not publish. Browser Use stops agent browsers after 4 hours and ties concurrency to lifetime payments ($200 for 50 sessions, $25,000 for 1,000), while Kernel keeps no disk and caps Start-Up at 150 browsers, so 300 user sandboxes and 1,000 jobs at once need Enterprise. bochka fits every scenario except 1,000 short jobs at once, where starts above 90 a minute are queued.
| Scenario | Browser Use | Kernel | bochka |
|---|---|---|---|
| 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 Browser Use when
you want to send a browser task and get a result back, with stealth, CAPTCHA solving and residential proxies on by default, and room to grow to 1,000 browsers.
- Send a task, get a result. For teams that want a hosted browser agent: send a task in plain words, pick a model, and never manage a browser.
- Concurrency that grows with spend. For large browser fleets: up to 1,000 sessions at once as your lifetime spend grows, with no monthly plan to buy.
- Open-source agent library. For teams that want to run the same agent locally: the browser-use library is MIT, with about 118k GitHub stars.
Use Kernel when
you want to build on raw browser infrastructure: SSH into the browser, free standby between steps, proxies with no extra charge, and browsers in the US, EU or Asia.
- A browser you can get inside. For agents that need more than CDP: SSH into the browser VM, run processes as root, and use a computer controls API.
- Free standby with memory kept. For agents that wait between steps: after 5 seconds idle a Kernel browser stops charging and comes back with its pages loaded.
- Proxies included, three regions. For scraping across markets: stealth proxies cost nothing extra, and browsers can run in the US, the EU or Asia.
Where bochka fits
Browser Use and Kernel both sell a browser, not a machine. If what you are really running is agents that browse and then also write code, install packages, run Docker or serve an app, bochka gives each one a full Linux VM with Chromium and a desktop inside. Keep Browser Use or Kernel for stealth scraping behind CAPTCHAs, where they are built for it.
A whole machine around the browser
Browser Use gives no shell, and Kernel's unikernel documents no Docker or /dev/kvm. An agent that browses and then builds needs a second machine on both, and you wire the files between them yourself.
Work that lasts, and files that stay
Browser Use agent browsers stop after 4 hours, and Kernel deletes a browser's files with it, keeping only cookies and storage in a profile. On bochka the disk is saved every minute, stops cost nothing, and you can fork a running sandbox.
Coding agents and keys kept out
bochka ships Claude Code, Codex and more, driven from outside by API. Its credentials proxy keeps real keys out of the sandbox, while Browser Use types secrets into the page and Kernel's vault fills can be read by page scripts.
Use bochka when your agent browses and also works: a shell, Docker, files and dev servers on a full VM with a disk that stays, a 60fps desktop and coding agents built in. Compare it one to one: bochka vs Browser Use and bochka vs Kernel.
Questions people ask
Is Browser Use cheaper than Kernel?
In the table, mostly yes. One agent running all month comes to $25 on Browser Use and $34 on Kernel, 50 agents in parallel to $178 against $625, and sandboxes for your users to $150 against $420. But Browser Use bills proxy traffic per GB, while Kernel's proxies and standby cost nothing.
Which is faster, Browser Use or Kernel?
Neither publishes the CPU behind a browser, and neither is in the CPU benchmark, so there is no fair speed comparison. Kernel publishes cold starts under 20 ms. bochka scored 26.69 runs per second at 4 vCPU / 8 GB.
Can Browser Use or Kernel run Docker?
No. Browser Use gives no shell on the browser machine, and Kernel's browser is a single-purpose unikernel with no container runtime documented, though you can SSH in and run processes. A bochka sandbox is a full VM with Docker, systemd and /dev/kvm.
How long can a session run?
Browser Use agent browsers stop after 4 hours. A Kernel browser has no documented cap while something drives it, and is deleted after an idle timeout you can set up to 72 hours. bochka has no session cap on paid plans and keeps its disk when it stops.
Which is better at getting past bot checks?
Both are built for it. Browser Use runs a hardened Chromium fork with per-session fingerprints, CAPTCHA solving and residential proxies on by default. Kernel's stealth mode adds an ISP proxy and a CAPTCHA solver, with proxies at no extra charge. bochka runs Chromium on datacenter IPs.
Can I use bochka with Browser Use or Kernel?
Yes. An agent on a bochka sandbox can open a Kernel browser over its API and CDP, or run the MIT browser-use library on bochka's own Chromium. Code, files and tools stay on the bochka VM, and stealth browsing goes to the browser service.
Try bochka
Install the CLI, then run bochka new.
Product preview