Unbrowse 3.0: From Browser Tool to Agentic Infrastructure

The wedge was speed: 3.6x faster than Playwright, 106x cheaper, zero browser overhead. That got agents in the door.

But speed was never the point. The point was the route graph -- a shared, collectively maintained index of every callable API route on the web, discovered by agents doing real work.

Unbrowse 3.0 is the release where the cathedral starts to show.

What changed

DAG workflow publishing

When Unbrowse captures a multi-step workflow -- login, search, add-to-cart, checkout -- it no longer flattens the sequence into a bag of endpoints. Each step is now published as a callable operation in a dependency graph, with its prerequisites and unlocks.

An agent that needs to search LinkedIn does not need to replay the entire login-search-filter-paginate sequence. It can invoke just the search step, because the graph knows what came before it and what comes after.

This is the difference between a list of API endpoints and a map of how a website actually works.

Publish review pipeline

Every endpoint that enters the shared marketplace now passes through a review gate. Auto-generated descriptions from DOM scraping are flagged. Generic labels like "Search form for reddit.com" are classified as unreviewed. Remote publish is blocked until an agent or human writes a proper description.

The marketplace was filling with noise -- low-quality skills that looked like hits but broke on execution. The review pipeline fixes the supply side. If you cannot describe what an endpoint does, it does not ship.

MCP tool surface overhaul

resolve is now explicitly cache-only. It searches the local cache and marketplace, returns what it finds, and stops. No more side effects. No more silent browser launches when the cache misses.

New tools -- review and publish -- are exposed so agents follow the correct capture flow:

go -> snap -> sync/close -> review -> publish

When resolve misses, the MCP response now returns actionable options: browse_only, capture_for_reuse, or auth_then_retry. Agents pick the right path instead of stalling.

Browse session proxy

go opens a proper Kuri-backed browser session. Snap, text, markdown, cookies, and eval commands work as a thin CDP proxy without auto-resetting state between calls.

This means multi-step browser workflows -- LinkedIn messaging, form filling, checkout flows -- now work end-to-end through Unbrowse. The browser is not a black box. It is a controllable session that the agent drives, and Unbrowse indexes passively in the background.

Value-aware DAG inference

The operation graph now detects workflow edges by observing when response values from one endpoint appear in request parameters of another. A search endpoint returns a list of IDs; a detail endpoint takes one of those IDs as a parameter. The graph connects them.

This catches workflow links that name-matching alone would miss. Compound values like 2025-2026, semesters/2, and modules/ABM5001.json no longer collapse into junk {id} templates.

Passive capture improvements

Performance API preloads and API-style resources are now harvested during passive browsing. When a page preloads api.example.com/data.json via the browser Performance API, Unbrowse captures it even if the HAR recording missed it.

Path binding evidence is preserved raw from reverse-engineering and deferred until the graph layer for semantic naming. This means the graph sees the real URL structure before any templating happens.

The architecture in one paragraph

Unbrowse watches real browser traffic, learns the internal API routes behind every website, and turns that knowledge into a shared graph. Each agent that browses a site contributes routes. Each agent that resolves a task consumes routes from the graph. The first visit pays full browser cost. Every subsequent visit hits the API directly -- 3.6x faster, 106x cheaper. The graph grows with usage. The more agents use it, the better it gets for everyone.

What this means for agents

If you are building agents that interact with websites, you no longer need to choose between browser automation (slow, expensive, fragile) and hand-written API wrappers (one site at a time, breaks when the API changes).

Unbrowse discovers the APIs automatically. The review pipeline ensures quality. The DAG tells agents how workflows connect. And the shared marketplace means your agent benefits from every other agent that has visited the same site.

npx unbrowse setup

Paper: Internal APIs Are All You Need
GitHub: unbrowse-ai/unbrowse
npm: npm install -g unbrowse

Fixes

• Kuri tabs are lazily allocated so cache-hit resolves no longer spawn stray blank browser tabs
• Stale CDP sockets are reconnected before retrying read commands
• Kuri warmup and transient connectivity failures are treated as recoverable instead of fatal
• DOM fallback descriptions are correctly classified as auto-generated
• Install script no longer runs skills.sh registration when setup was skipped or failed
• Packaged binary reports correct version instead of "unknown"
• Cached marketplace skills are rejected when they lack the required search binding