Kernel vs Notte
Kernel and Notte both hand your agent a cloud browser with stealth built in. Kernel is browser infrastructure: each browser runs on its own unikernel, sleeps for free when idle and has no session cap while driven, while Notte wraps timed browser sessions in its own browser agent, personas and Functions.
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.
Notte
Notte is a cloud browser platform for AI agents: you start hosted Chrome sessions through an API, SDK, CLI or MCP server.
Each Notte session is a hosted browser you control over CDP, Playwright or Notte's own actions, with residential proxies, captcha solving and a consistent fingerprint on by default. Around it Notte sells a task-driven browser agent, vaults for passwords, personas with their own email and phone number, and Python Functions that turn a browser script into an API endpoint. It is a different kind of product from boat: a browser service, not a general sandbox, so this page compares the two where they overlap, which is agents that use the web.
- Backing
- Backed by Y Combinator
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 | Notte: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither browser keeps a disk or documents Docker, so a coding agent cannot build and test there; that work fits a full VM like boat's. | 98th of 367, with limits $873 a month | 44th of 367, with limits $121 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Notte sessions end after at most 300 minutes on Startup, and a Kernel browser's files go when it is deleted, so an always-on assistant needs a machine like boat to live on. | 203rd of 366, with limits $2,033 a month | 99th of 366, with limits $365 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 | 220th of 345, with limits $100 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 Notte's Startup limit of 100, and each user gets a browser rather than a machine. | 228th of 361, with limits $768 a month | 195th of 361, with limits $105 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 | 222nd of 360, with limits $500 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 | 227th of 364, with limits $100 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 | 230th of 377, with limits $100 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither has a disk that stays to develop on; Kernel at least gives SSH into its browser VM, while Notte has no shell at all. | 144th of 368, with limits $33 a month | 255th of 368, with limits $100 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 for its browser; Notte controls a browser only, and boat streams a whole 60fps Linux desktop. | 38th cheapest of 369 $1,878 a month | 76th of 369, with limits $100 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 All three fit: Notte ranks 2nd with stealth on by default, boat ranks 7th with Chrome on a full VM, and Kernel ranks 21st with a browser over CDP. | 21st cheapest of 367 $366 a month | 2nd cheapest of 367 $100 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 browsers fit for startup-scale scraping; Notte bills residential proxy traffic at $10 per GB, while Kernel does not charge for its proxies. | 45th cheapest of 346 $443 a month | 7th cheapest of 346 $100 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 strong here: Notte ranks 2nd and Kernel ranks 4th, since stealth proxies and CAPTCHA solving come built in, while boat uses datacenter IPs. | 4th of 338, with limits $6,000 a month | 2nd of 338, with limits $975 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 | 143rd of 360, with limits $100 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 | Notte | boat |
|---|---|---|---|
| What you get | Chromium on its own Unikraft-based unikernel, with an app runtime for your agent code | A hosted browser session reached through an API, SDK, CLI or MCP server; isolation model not published | A full Linux VM with its own kernel, with Chromium and a desktop on it |
| Machine size | 1 GB headless, 8 or 16 GB headful; vCPU count not published | Machine size not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB by plan |
| How long a session runs | Stays alive while something drives it; deleted after an idle timeout of 60 seconds by default, up to 72 hours | 15 min on Free, 120 min on Developer, 300 min on Startup | No session cap on paid plans |
| Idle and wake | Standby after 5 seconds idle with a memory snapshot and no usage charge; a new connection picks it up | No pause or resume; the next session starts with a fresh browser | Stop and resume by API; resume reboots from disk, and a stopped sandbox costs nothing |
| What survives a session | Profiles keep cookies, storage and browser state, not files | An opt-in profile keeps cookies, local storage and session storage | The whole disk, with snapshots every minute and on stop |
| Getting past bot checks | Stealth mode with an ISP proxy and a CAPTCHA solver; residential proxies; proxies not charged | Residential proxies ($10/GB, on by default), captcha solving and a matching Chrome fingerprint | Datacenter IPs; bring your own proxy or captcha service |
| Running your own code | SSH into the browser VM and process exec with an as_root option | Python Functions with a run() entry point, called by API, webhook or schedule; no shell | Root shell over SSH, any language |
| Docker and nested virtualization | A single-purpose unikernel; no container runtime or /dev/kvm documented | No Docker | Docker, systemd and /dev/kvm on every machine |
| Desktop and computer use | Headful Chromium with Live View, a computer controls API, CDP and session replays | Browser only, with a live view you can embed | 60fps Linux desktop and Chromium, computer use and browser control, embeddable stream |
| Built-in agents | A Claude Agent SDK app template that installs Claude Code when you deploy your app | Notte's own browser agent: start it with a task, stream its logs, export the run as code | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Keeping secrets safe | Vaults fill logins into forms, where page scripts can read them; managed auth keeps sign-ins in profiles | Vaults fill passwords, cards and 2FA codes so the LLM never sees them; personas with their own email and phone | AI credentials proxy: real keys never enter the sandbox, for model providers and any HTTPS API |
| Reaching it from outside | No inbound ports; tokenized CDP and Live View URLs, and SSH port forwarding | No open ports; a short-lived signed live-view URL per session | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Where it runs | us-east, eu-west and ap-southeast; region choice from the Start-Up plan | Session region not published; built-in proxies exit in the US unless you pick a country | EU only: Germany, Finland, France, with EU data residency |
| Self-hosting | Hosted; browser images are public on GitHub | Source-available framework runs on local Chromium; on-premise and bring-your-own-cloud on Enterprise | Hosted only |
Every feature Battleships tracks (43)
| Feature | Kernel | Notte | 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 | 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 | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | Not published | Not published | 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 | Not published | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
There is no comparable measurement for either. Kernel and Notte were not in StarSling's public CPU benchmark, and neither publishes how many vCPUs a browser gets. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB; for browsing work, speed depends mostly on the sites, the proxy and the model.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Kernel and Notte 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 | Notte, 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 | $100 · Startup · 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 | $100 · Startup · 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 | $100 · Startup · 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 | $100 · Startup · 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 | $100 · Startup · with limits | $2,000 · $2000/mo · with limits |
Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active, so an 8 GB headful browser costs more per hour than 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.
Notte: Notte's plan fee ($0, $20 or $100 a month) comes back as credits that expire each cycle, spent on browser sessions ($0.01 an hour), Functions ($0.05 an hour), residential proxies ($10 per GB) and model tokens. Proxies are on by default, so traffic is billed per GB unless you turn them off.
Notte: 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
Neither Kernel nor Notte fits any scenario in the table, because each one needs a machine: a set size, a disk that stays, or Docker. Notte also ends sessions at 300 minutes on Startup, and Kernel's prices are for a 1 GB headless browser rather than a 4 vCPU / 8 GB VM. For 300 sandboxes for your users or 1,000 jobs at once, Kernel's Start-Up allows 150 browsers and Notte's Startup 100, so both need Enterprise. On boat the 1,000-job burst is the one that does not fit: bursts above 90 starts a minute are queued, and it needs more starts per day than the top plan allows.
| Scenario | Kernel | Notte | 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 raw browser infrastructure: browsers that sleep for free between steps, run as long as you drive them, sit in the US, EU or Asia, and come with proxies at no extra charge.
- Free standby with memory kept. Useful if agents sit idle between steps: a Kernel browser stops charging after 5 seconds idle and comes back with its pages loaded.
- No session clock while driven. Useful for long browsing jobs: a Kernel browser stays alive as long as something drives it, while Notte sessions end at 300 minutes on Startup.
- Regions, SSH and free proxies. Useful if users are in the US or Asia, or you want SSH into the browser and proxies that cost nothing extra.
Use Notte when
you want browsing handled for you: a task-driven browser agent, personas with email and phone, scheduled Functions, stealth on by default, or a self-hosted option on Enterprise.
- Browsing handled for you. Useful if you want a task-driven browser agent, personas with their own email and phone, and scheduled browser Functions.
- Stealth on by default. Useful for sites that block bots: every Notte session starts with residential proxies, captcha solving and a matching fingerprint.
- Source-available and on-premise. Useful if you must run it yourself: the framework is on GitHub under SSPL, and Enterprise adds on-premise and your own cloud.
Where boat fits
Kernel and Notte are browsers for agents, not general sandboxes, so this is about where they overlap with boat: agents that use the web. If what you are really running is agents that browse and then also install packages, build, run Docker or keep files for days, boat gives each one a full VM with Chromium and a 60fps desktop on it. If the job is pure browsing on sites that fight bots, Kernel or Notte is the better tool, and an agent on boat can call either one.
A whole machine next to the browser
Kernel's unikernel documents no Docker, and Notte gives no shell at all. An agent that browses and then builds needs a second machine beside the browser, and you move files between them yourself.
Files that stay, and no reset
A Kernel browser's files go when it is deleted, and Notte sessions end after 300 minutes on Startup; both keep only cookies and storage. boat keeps the disk, snapshots it every minute and can fork a running sandbox.
Coding agents and a key proxy built in
Neither ships coding agents you drive from outside. Kernel's vaults type logins into pages that scripts can read; boat's credentials proxy keeps real API keys out of the machine for any HTTPS API.
Use boat when the agent does more than browse: it writes and runs code, uses Docker, keeps files between runs, works for hours, or needs a 60fps desktop and coding agents on one VM. Compare it one to one: boat vs Kernel and boat vs Notte.
Questions people ask
Is Kernel cheaper than Notte?
It depends on the work. For browser-use agents, where both fit, our model comes to $366 a month on Kernel against $100 on Notte, and boat to $200. Kernel's free standby and free proxies help idle-heavy work, while Notte bills $10 per GB of proxy traffic by default.
Which is faster, Kernel or Notte?
There is no comparable measurement: neither was in StarSling's CPU benchmark and neither publishes a vCPU count. Kernel publishes cold starts under 20 ms for its unikernels. boat measured 26.69 runs per second at 4 vCPU / 8 GB.
Can Kernel or Notte run Docker?
No. Kernel's browser is a single-purpose unikernel with no container runtime documented, though you can SSH in and run commands. Notte has no shell, only Python Functions. On boat every sandbox is a full VM with Docker, systemd and /dev/kvm.
Which is better for scraping sites that block bots?
Both are built for it: Notte ranks 2nd and Kernel 4th for mass scraping in our table, at $975 a month on Notte against $6,000 on Kernel in our model. Notte turns on residential proxies and captcha solving by default; Kernel's stealth mode adds an ISP proxy and a CAPTCHA solver, with proxies not charged.
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. Notte sessions end after 15, 120 or 300 minutes by plan. Paid boat plans have no session cap.
Can I use Kernel or Notte from a boat sandbox?
Yes. A boat sandbox has open internet, so an agent on it can open a Kernel browser over CDP or call Notte's API, SDK or MCP server. The agent keeps its code and files on boat and sends hard-to-reach pages to the browser service.
Try boat
Install the CLI, then run boat new.
7-day free trial