Hyperbrowser vs Kernel
Both sell cloud browsers for AI agents, with stealth, proxies and CAPTCHA solving. Hyperbrowser adds Firecracker sandboxes and fetch, scrape and search APIs under one credit balance, while Kernel puts each Chromium on its own unikernel, bills memory per second and charges nothing while a browser sits idle.
The companies and products
Hyperbrowser
Hyperbrowser calls itself the AI agents' gateway to the internet: cloud browsers, sandboxes, web data APIs and browser agents behind one API and one credit balance.
Its main product is a cloud Chrome session you drive with Playwright or Puppeteer, with stealth mode, residential proxies, CAPTCHA solving, saved profiles and recordings. Next to it Hyperbrowser sells Sandboxes, Firecracker VMs on Ubuntu 24.04 that live up to 24 hours, with memory snapshots, volumes and outbound rules, plus Fetch, Scrape and Search APIs and hosted browser agents. It is a browser and web data platform more than a general sandbox, so this page compares where it overlaps with bochka: agents that browse, and agents that run code.
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. “20th cheapest of 367” means 19 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 | Hyperbrowser: 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 Both are a compromise: neither documents Docker inside, Hyperbrowser's sandboxes lose their disk on stop and Kernel's browser keeps no files, so builds and tests fit bochka better. | 136th of 367, with limits $1,206 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 lives on one machine all month hits Hyperbrowser's 24-hour sandbox lifetime and loses its files when a Kernel browser is deleted; bochka keeps the disk and has no session cap on paid plans. | 255th of 366, with limits $3,650 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 Hyperbrowser's memory snapshots start many sandboxes from a warm state, which suits short code runs better than a Kernel browser built only for Chromium. | 244th of 345, with limits $246 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 sessions at once is more than Hyperbrowser's Scale limit of 100 or Kernel's Start-Up limit of 150, so both need Enterprise, and each user gets a browser rather than a machine. | 245th of 361, with limits $1,029 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 | 262nd of 360, with limits $4,972 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 | 253rd of 364, with limits $400 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 | 238th of 377, with limits $120 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 | 240th of 368, with limits $73 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 with Live View and a computer controls API on a headful browser, Hyperbrowser runs hosted computer-use models in its browser, and bochka streams a 60fps Linux desktop where the agent can use any app. | 144th of 369, with limits $360 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 and sit side by side: Hyperbrowser ranks 20th and Kernel 21st, each giving a stealth Chromium over CDP, while bochka adds a full VM where the agent can also run code. | 20th cheapest of 367 $360 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 Both fit at startup scale; Hyperbrowser also sells fetch and scrape APIs per page, so some jobs need no browser at all. | 32nd cheapest of 346 $366 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 Kernel ranks 4th and Hyperbrowser 11th here: both bring stealth, residential proxies and CAPTCHA solving, but Kernel does not charge for proxies while Hyperbrowser bills $10 per GB of proxy data. | 11th of 338, with limits $9,750 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 | 33rd of 360, with limits $356 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 | Hyperbrowser | Kernel | bochka |
|---|---|---|---|
| Kind of product | Cloud browser sessions first, plus Firecracker sandboxes and web data APIs | A managed Chromium browser per session, with an app runtime for your code | A full Linux VM per sandbox, with a desktop and Chromium inside |
| Isolation | Firecracker VM per sandbox; browser isolation technology not published | Every browser runs on its own Unikraft-based unikernel | Every sandbox is a full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Sandboxes up to 32 vCPU and 256 GiB RAM, disk up to 32 GiB; browser size not published | 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 |
| Session length | Browsers up to 12 hours; sandboxes up to 24 hours from VM start | A browser stays alive while something drives it; once idle it is deleted after a timeout of up to 72 hours | No cap on paid plans; you set the time to live |
| Files after a stop | A stopped sandbox is gone; files survive on a mounted volume or in a memory snapshot | The browser is deleted; profiles keep cookies, storage and browser state, not files | The disk persists, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Idle browsers | Billed per browser-hour while the session runs | Standby after 5 seconds idle with a memory snapshot and no usage charge; a new connection picks it up | Stop and resume by API; resume reboots from disk, with no memory snapshot |
| Snapshots and fork | Memory snapshot of a running sandbox, then start many new sandboxes from it | No fork; browser pools keep fresh browsers warm | Fork a running sandbox with its disk; no memory snapshots |
| Docker and nested virtualization | Docker builds images on your machine; Docker or /dev/kvm inside a sandbox is not documented | A single-purpose unikernel; no container runtime or /dev/kvm documented | Docker, systemd and /dev/kvm on every machine |
| Browser and computer use | Cloud Chrome over CDP with live view and recordings; hosted HyperAgent, Browser Use and computer-use models | Headful Chromium with Live View, a computer controls API, CDP and session replays | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Bot detection | Stealth mode, residential proxies and CAPTCHA solving on paid plans; proxy data $10 per GB; ultra stealth on Enterprise | Stealth mode with an ISP proxy and a CAPTCHA solver; residential proxies; proxies not charged | Datacenter IPs and Chromium; no CAPTCHA solving |
| Reaching the machine | HTTPS URL per exposed sandbox port through a shared regional proxy; no raw TCP or own IP | No inbound ports; tokenized CDP and Live View URLs, and SSH port forwarding | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Coding agents | Base images with the Claude Code, Codex or OpenClaw CLI installed, run through the exec API | A Claude Agent SDK app template that installs Claude Code when you deploy your app | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Keys are passed in as environment variables to the process | Vaults fill logins into forms, where page scripts can read them; managed auth keeps sign-ins in profiles | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Regions | us-central, us-east, us-west and europe-west; asia-south on Enterprise and Select plans | us-east, eu-west and ap-southeast; choosing a region needs the Start-Up plan | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Hyperbrowser | Kernel | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | No | No | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | No | 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 | No | Yes | No |
| Windows | No | No | No |
| Arm64 | Not published | Not published | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | No | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Yes | Yes |
Performance
There is no comparable measurement for either. Neither Hyperbrowser nor Kernel was in StarSling's public CPU benchmark, and neither publishes the vCPU count of a browser, so there is nothing to set against bochka's 26.69 runs per second at 4 vCPU / 8 GB. On start times, Hyperbrowser publishes under 50 ms for sandboxes and under 500 ms for a ready browser, and Kernel publishes cold starts under 20 ms.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Hyperbrowser 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 | Hyperbrowser, 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 | $16 · Free · 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 | $73 · Free · 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 | $792 · Scale · 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 | $450 · Scale · 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 | $994 · Scale · with limits | $747 · Start-Up · with limits | $2,000 · $2000/mo · with limits |
Hyperbrowser: Everything spends one credit balance at $0.001 a credit: browsers cost $0.10 a browser-hour plus $10 per GB of proxy data, and sandboxes $0.045 per vCPU-hour plus $0.015 per GiB-hour. Startup ($30) and Scale ($100) turn their fee into credits that reset each month.
Kernel: Kernel bills $0.0000166667 per GB-second of memory while a browser is active, so a 1 GB headless browser costs 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.
Kernel: 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
The table prices Hyperbrowser's browser session and Kernel's 1 GB headless browser, the closest things each sells by default, so neither is a 4 vCPU / 8 GB machine with a 50 GB disk and neither fits the scenarios that need files or Docker. Concurrency is the other limit: 100 browsers at once on Hyperbrowser Scale and 150 on Kernel Start-Up, so 300 sessions for your users and 1,000 short jobs at once need Enterprise on both. On bochka, 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 | Hyperbrowser | 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 Hyperbrowser when
you want browsers, short code sandboxes and fetch, scrape and search APIs from one vendor and one credit balance, or regions across the US.
- Sandboxes next to the browser. Useful if your agent also runs code: Firecracker sandboxes up to 32 vCPU and 256 GiB share one credit balance with the browsers.
- Fetch, scrape and search APIs. Useful if you mostly need page content: Hyperbrowser sells fetch, scrape and search per page or query, plus hosted browser agents.
- Warm starts and outbound rules. Useful for many short runs: start sandboxes from a memory snapshot, behind default-deny outbound rules by domain, IP or CIDR.
Use Kernel when
your agent only needs a browser that sits idle a lot: free standby, proxies with no per-GB charge, saved logins, replays and browsers in the US or Asia.
- Free standby with memory kept. Useful if agents pause between steps: after 5 seconds idle a Kernel browser stops charging and wakes with its pages loaded.
- Proxies included. Useful for heavy scraping: stealth mode, ISP and residential proxies and a CAPTCHA solver, with no per-GB proxy charge.
- Ready browser tooling. Useful if you want saved logins, session replays, browser pools and SSH into the browser without building them yourself.
Where bochka fits
If what you are really running is agents that browse and then do work, such as installing packages, building in Docker or running a dev server, a browser alone is not enough. bochka gives each agent a full Linux VM with Chromium and a 60fps desktop inside, a disk that stays and coding agents you drive from outside. For stealth scraping behind CAPTCHAs at volume, Hyperbrowser or Kernel is the better tool, and an agent on bochka can call either over CDP.
A full VM with Docker and /dev/kvm
Neither Hyperbrowser's sandboxes nor Kernel's unikernel browsers document Docker inside, so an agent that runs docker compose or an emulator stops there. The workaround is a second machine you wire to the browser yourself.
A disk that stays and no session cap
A Hyperbrowser sandbox lives at most 24 hours and loses its disk on stop, and a deleted Kernel browser keeps only cookies and storage. Long tasks must save to volumes, snapshots or the file API before time runs out.
Coding agents and keys kept outside
On bochka you prompt and steer Claude Code or Codex through one API, and the credentials proxy keeps real keys off the machine. Hyperbrowser passes keys as environment variables, and Kernel's vault logins can be read by page scripts.
Use bochka when your agent browses and also works: installs, builds, Docker 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 Hyperbrowser and bochka vs Kernel.
Questions people ask
Is Hyperbrowser cheaper than Kernel?
In the table Kernel comes out lower in every scenario: one agent running all month is $73 on Hyperbrowser against $34 on Kernel, and 50 agents in parallel $792 against $625. Kernel also charges nothing for proxies or standby, while Hyperbrowser bills $10 per GB of proxy data. Neither is a full machine with a disk, which on bochka comes to $26 and $317 for the same two scenarios.
Which is faster, Hyperbrowser or Kernel?
Neither has a CPU benchmark you can compare, and neither publishes how many vCPUs a browser gets. Kernel publishes cold starts under 20 ms, and Hyperbrowser under 50 ms for sandboxes and under 500 ms for a ready browser.
Can Hyperbrowser or Kernel run Docker?
Hyperbrowser uses Docker on your own machine to build a custom sandbox image, but its docs do not describe running Docker inside a sandbox. Kernel's browser is a single-purpose unikernel and documents no container runtime. Every bochka sandbox runs Docker, systemd and /dev/kvm.
How long can a session run?
Hyperbrowser caps browser sessions at 12 hours and sandboxes at 24 hours from VM start. A Kernel browser stays alive while something drives it, and once idle it is deleted after a timeout of up to 72 hours. bochka has no session cap on paid plans and keeps the disk when you stop.
Which is better for stealth scraping?
Both have stealth mode, residential proxies and CAPTCHA solving. Kernel includes proxies at no extra charge and lets you bring your own on Start-Up, while Hyperbrowser bills proxy data at $10 per GB and keeps ultra stealth and your own proxy for Enterprise.
Can I use Hyperbrowser or Kernel with bochka?
Yes. An agent on a bochka sandbox can open a Hyperbrowser or Kernel browser over CDP and keep its code, files and tools on the bochka VM. That puts stealth browsing on the browser service and the rest of the work on a machine that keeps its disk.
Try bochka
Install the CLI, then run bochka new.
Product preview