MCP + CDP Browser Automation

Control any browser.
From any AI agent.

Scout is a Chrome extension that exposes your browser to AI agents through the Model Context Protocol. Direct CDP access. No proxy servers. No remote browsers. Your session, your context, your control.

agent.tstypescript
// Connect any MCP agent to your browser
const { tools } = await client.listTools();
// → browser-navigate, browser-snapshot, browser-action,
//   browser-extract, browser-screenshot, ...

await client.callTool({
  name: "browser-navigate",
  arguments: { action: "goto", url: "https://example.com/dashboard" },
});

const snapshot = await client.callTool({
  name: "browser-snapshot",
  arguments: {},
});
// → Structured accessibility tree of the live page

const content = await client.callTool({
  name: "browser-extract",
  arguments: { property: "text", selector: "#metrics-panel" },
});
// → Text content from the selected element

Built for browser automation at protocol level

Scout combines the Model Context Protocol with Chrome DevTools Protocol to give AI agents direct, reliable access to browser capabilities.

⬡

MCP Tool Server

Full Model Context Protocol implementation. Connect any AI agent to real browser actions through a standardized tool interface.

▸

Chrome DevTools Protocol

Direct CDP integration for low-level browser control. Navigate, interact, extract, and observe with protocol-level precision.

◈

Extension-First Architecture

Runs inside your browser as a Chrome extension. No proxy servers, no remote browsers, no MITM. Your session, your cookies, your context.

◉

Accessibility Snapshots

Structured page understanding through the accessibility tree. No brittle CSS selectors. No DOM scraping. Semantic structure only.

◆

DOM-Native Extraction

Structured data extraction through DOM property readers. Extract article content, text, HTML, markdown, attributes, and element state from any page.

◎

Session Persistence

Maintains browser state across tool calls. Authenticated sessions, cookies, and local storage persist naturally.

Extension-first architecture

Scout runs where your browser runs. No infrastructure to manage, no remote browser farms, no proxy layer between you and the web.

AI Agent (Claude, Gemini, GPT, ...)
MCP Tool Calls
↓ MCP Protocol
Scout MCP Server
Tool Registry + Session Manager
↓ WebSocket
Scout Chrome Extension
CDP Session per Tab
↓ CDP
Your Chrome Browser
Authenticated sessions, cookies, extensions
No proxy serversNo remote browsersNo MITMNo infrastructure

Service Worker

Persistent background process manages WebSocket connections and routes CDP commands to the correct tab sessions.

CDP Sessions

Each controlled tab gets its own Chrome DevTools Protocol session with independent state, events, and lifecycle.

MCP Tool Server

Standard MCP interface exposes browser capabilities as discoverable, typed tools that any compatible agent can call.

Event System

Real-time CDP event streaming for network requests, console output, dialog prompts, and page lifecycle changes.

Four steps to browser automation

From installation to structured data extraction in minutes. No infrastructure setup, no browser farm configuration, no SDK integration.

01

Install the Extension

Add Scout to Chrome. The extension establishes a WebSocket connection to the orchestration server and exposes CDP capabilities.

02

Connect Your Agent

Point any MCP-compatible AI agent at Scout's tool server. The agent discovers available browser tools through the MCP protocol.

03

Execute Browser Actions

The agent sends tool calls. Scout translates them to CDP commands, executes them in your browser, and returns structured results.

04

Observe and Extract

Get accessibility snapshots, intercept network traffic, capture screenshots, and extract structured data — all through the tool interface.

Just ask your AI

You don't write code to use Scout. You tell your AI what you need — in Cursor, Claude, VS Code, or any MCP client — and Scout handles the browser.

Extraction

“Go to techcrunch.com and extract the top 5 headlines with their URLs”

Scout navigates to the page, takes an accessibility snapshot, identifies article elements, and returns structured JSON.

Interaction

“Fill out the contact form on example.com with my name and email, then submit it”

Scout snapshots the form, locates input fields by their accessible names, fills each one, and clicks submit.

Testing

“Screenshot our pricing page at 375px, 768px, and 1440px widths”

Scout resizes the viewport three times, capturing a full-page screenshot at each breakpoint.

Debugging

“Open our staging site and tell me if there are any console errors or failed API calls”

Scout monitors the browser console and network activity, then reports any errors or failed requests.

Research

“Crawl docs.example.com and find every page that mentions "authentication"”

Scout crawls the documentation site, extracts each page's content, and filters for mentions of the keyword.

Workflow

“Log into the admin panel, go to settings, and export the user list as CSV”

Scout chains navigation, form interaction, and data extraction across multiple pages in a single session.

70+

MCP tools

12

Tool categories

<5 min

Setup time

0

External dependencies

8+

Compatible MCP clients

10

Browser actions per batch

Why Scout is different

Most browser automation tools require you to run browsers somewhere else. Scout runs in the browser you already have.

Scout

Runs in your browser

Scout uses your real browser session. Authenticated state, extensions, and context are preserved naturally.

Others

Runs in a remote browser

Scout

AI-only extraction

No brittle selectors. AI interprets page structure semantically through accessibility snapshots.

Others

CSS selector-based

Scout

MCP standard protocol

Any MCP-compatible agent can use Scout. No vendor lock-in, no custom SDK required.

Others

Proprietary APIs

Scout

Extension architecture

No infrastructure to manage. Install an extension and connect.

Others

Proxy or browser-as-a-service

Scout

CDP native

Direct Chrome DevTools Protocol access. Full browser capabilities, not a watered-down HTTP wrapper.

Others

HTTP API abstraction

What you can build

Scout provides the primitives. You decide the application. From testing to research, monitoring to extraction.

Automated Testing

Run end-to-end tests with AI-driven interaction. No test scripts to maintain — the agent adapts to UI changes automatically.

Data Extraction

Extract structured data from any website. AI understands page semantics, not DOM structure. Works on SPAs, dynamic content, and authenticated pages.

Workflow Automation

Automate multi-step browser workflows across any web application. Form filling, navigation, file uploads, and cross-tab coordination.

Monitoring

Continuously monitor web pages for changes. Price tracking, content updates, availability checks — with browser-level fidelity.

Research & Analysis

Systematic web research with AI comprehension. Navigate complex sites, aggregate information, and produce structured reports.

QA & Regression

Visual regression testing and quality assurance. Compare accessibility snapshots, validate content, and verify interactive behaviors.

Developer-first interface

Standard MCP protocol. Typed tool definitions. Structured responses. Everything you need to integrate browser automation into your agent.

import { Client } from "@modelcontextprotocol/sdk/client";

const client = new Client({
  name: "my-agent",
  version: "1.0.0",
});

// Discover available browser tools
const { tools } = await client.listTools();
// → browser-navigate, browser-snapshot, browser-action,
//   browser-extract, browser-screenshot, ...

// Navigate to a page
await client.callTool({
  name: "browser-navigate",
  arguments: { action: "goto", url: "https://app.example.com" },
});

// Get structured page content
const snapshot = await client.callTool({
  name: "browser-snapshot",
  arguments: {},
});
API Reference →Tool Catalog →Configuration Guide →Examples →

Engineering guarantees

Scout is built with the reliability expectations of infrastructure software. Here's how it works under the hood.

Deterministic Execution

Every tool call returns a structured result with a defined schema. Success or failure, with full context. No silent degradation, no undefined behavior.

-Typed tool inputs and outputs via MCP schema
-Explicit error codes with actionable messages
-No retry loops that mask failures

Execution Model

Tool calls are processed sequentially per session. Each call waits for the browser to reach a stable state before returning. No race conditions.

-Sequential execution within a tab session
-Network idle detection before returning
-Configurable timeouts with deterministic behavior

Concurrency Handling

Multiple tabs can be controlled concurrently, each with its own independent CDP session. Sessions don't interfere with each other.

-Isolated CDP sessions per tab
-Independent event streams
-No shared state between sessions

Safety Constraints

Governance layer prevents dangerous operations. Navigation to chrome:// and file:// URLs is blocked. Credit limits prevent runaway automation.

-URL scheme allowlisting
-Credit-based rate limiting
-Configurable operation boundaries

Reliability Model

WebSocket connections auto-reconnect. Interrupted sessions are cleanly terminated. No zombie browser states or orphaned processes.

-Automatic reconnection with backoff
-Clean session teardown on disconnect
-Heartbeat monitoring for connection health

Performance Characteristics

Extension architecture means zero network latency for CDP commands. Operations execute directly in your browser's process — no serialization overhead.

-Sub-millisecond CDP command dispatch
-No remote browser network round-trips
-Memory-efficient accessibility snapshots

Start automating your browser

Install the Scout extension. Connect your AI agent. Ship browser automation that works.