Kernel browser infrastructure

Kernel gives an agent a real, disposable browser in the cloud — with the persistence, replay and deployment tooling that turns a demo script into something you can actually run in production.

Start your projectRun a free site audit
  • Cloud browsers for agents
  • Persistent profiles & replay
  • Deployed, not laptop-bound

Kernel development at ZeroPixel

Kernel is browser infrastructure built for the agent era: sandboxed Chromium instances you can start in a second, drive over standard automation protocols, watch live, and throw away when they're done. The difference from running Chrome yourself isn't capability — it's everything around it, which is the part that decides whether an automation survives contact with production.

The features that matter in practice are unglamorous. Persistent browser profiles, so an agent that logged in yesterday isn't fighting a two-factor prompt today. Session recording, so a failed run can be watched rather than reconstructed. Live view, so a human can take the wheel when an agent hits something it shouldn't decide alone. And deployment tooling, so the automation runs on a schedule in the cloud instead of on a laptop that someone eventually closes.

We build on it where the work is genuinely agentic — tasks that vary run to run, that need judgement about what to click next, or that involve staying logged into several systems at once. For deterministic, repeatable extraction, a straightforward Playwright job is often the better and cheaper answer, and we'll say so.

What we build on Kernel

The common thread is an agent that has to act on the real web — and a business that needs to see exactly what it did.

Agents

Agents that use the web

Agents that research, gather and act across real sites — with defined boundaries, approval steps, and a stop button that works.

Workflows

Scheduled browser workflows

Multi-step jobs across several logged-in systems, running on a schedule in the cloud with retries and escalation when they get stuck.

Operations

Session replay & run history

Every run recorded and searchable, so you can prove what happened, diagnose a failure quickly, and audit an agent's actions after the fact.

Integration

Wiring agents into your systems

Results landing in your CRM, database or Slack rather than a log file — the step that turns an interesting demo into a working process.

Why hire ZeroPixel for Kernel work

Agents with a leash
An agent with a browser and no constraints is a liability. We define what it may touch, require approval before anything irreversible, and log every action — so autonomy is a feature rather than a risk you discover later.
Production, not prototype
The gap between an agent that works in a demo and one that runs unattended for six months is monitoring, error handling, credential management and cost control. That gap is the actual job, and it's the part we build.
Straight about when it's overkill
Half the tasks people want an agent for are better served by an API call or a fifty-line script. We'll point that out before quoting for the sophisticated version — it's cheaper for you and it works better.

Kernel — common questions

What is Kernel, in plain terms?
It's a service that gives software its own web browser in the cloud. Instead of your automation needing a computer somewhere with Chrome open, it asks Kernel for a browser, uses it, and hands it back. The useful extras are that the browser can remember logins between runs, every session can be recorded for review, and a person can watch or take over live.
Kernel or Browserbase?
Both provide cloud browsers and we build on both. Kernel's strengths lean towards agents that need to persist state and be deployed as long-running services; Browserbase is very strong for high-volume automation and data extraction. Honestly, for most jobs either would work, and the deciding factors tend to be your existing tooling and cost at your volume. We'll benchmark rather than guess.
Can an agent handle logins and two-factor authentication?
Logins yes, with credentials stored in a secrets manager rather than in code, and persistent profiles so sessions survive between runs. Two-factor is more nuanced: app-based codes can be automated where you control the account and it's permitted, while SMS and hardware keys usually need a human step. We design the flow around a person's involvement rather than pretending it away.
How do we know what the agent actually did?
Every run produces a recording and a structured log of the actions taken and the data touched. For anything with financial or legal consequence we also build an approval step, so the agent proposes and a person confirms. That audit trail matters both for trust internally and for UK GDPR accountability if personal data is involved.
What does an agent build cost?
A single well-defined workflow is typically a low-to-mid four-figure project. Multi-system agents with approval flows and integrations are quoted on scope after a short discovery. Fixed written quote before we start, and we'll tell you up front if a simple script would do the same job for a fraction of it.

Beyond Kernel

A stack is a set of choices that have to work together — these are the pieces we most often pair with Kernel, and where we do it.

Building with Kernel?

Tell us what you're making — we'll reply within one working day with an honest take and a fixed quote.

Start your projectsales@zeropixel.io