The Agentic Web

Why WebMCP?

From simulating users to calling APIs.

The Problem

Today, AI agents interact with websites by simulating users. They launch headless browsers, render pages, and use AI to interpret the DOM. Modern tools like Firecrawl, Exa, and Jina have improved significantly — using LLMs for resilient extraction and structured data output.

But even the best crawlers share fundamental limitations when it comes to performing actions on websites:

Indirect

Agents simulate clicks and form fills through the UI. Selector-based automation breaks on DOM changes; AI-based extraction adds latency and cost.

Overhead

Every interaction requires browser rendering, JavaScript execution, and DOM parsing. This adds 2-10 seconds of overhead per page.

No Declared Intent

Sites can use robots.txt and auth, but have no structured way to declare what actions agents should take or how.

The Solution

WebMCP flips the model. Instead of agents scraping websites, websites declare structured tools that agents call directly.

Typed Inputs (W3C Spec)

Every tool has a JSON Schema defining exactly what parameters it accepts. No guessing.

Structured Responses

Tools return JavaScript values, not raw HTML. The spec defines execute() callbacks that return structured data.

Safety Annotations

The W3C spec provides readOnlyHint. Our SDK extends this with read/write/danger classification for richer safety signals.

Side-by-Side Comparison

DimensionWeb CrawlingWebMCP
PurposeExtract content and simulate user interactionsCall structured, typed tools declared by the site
DirectionAgent pulls data and guesses UI intentSite publishes capabilities for agents to invoke
SchemaAI-inferred — modern crawlers use LLMs to interpret pagesJSON Schema with typed inputs (spec) + safety annotations (SDK)
SafetyNo structured safety signals from the sitereadOnlyHint (spec) + read/write/danger levels (SDK extension)
StabilitySelector-based scraping breaks on DOM changes; AI crawlers more resilientStable contract — tools are versioned and schema-defined
OverheadSeconds of browser rendering + DOM parsing per pageNear-zero overhead — direct to application logic
Controlrobots.txt and auth exist, but limited control over interpretationSite declares exactly what tools to expose and how
ExamplesFirecrawl, Exa, Jina, Playwright automationnavigator.modelContext.getTools()

Concrete Example

An AI agent needs to "Book a flight to Tokyo". Compare the two approaches:

With Web Crawling

  1. 1Launch headless browser, navigate to airline.com
  2. 2Wait for JS to render, parse DOM for search form
  3. 3Guess which input is "destination" by label text or placeholder
  4. 4Fill form, click search, wait for results page to load
  5. 5Parse flight cards from HTML, extract prices with CSS selectors
  6. 6Click "Book" button, hope the flow has not changed since last week
6 fragile steps. Any DOM change breaks it.

With WebMCP

  1. 1Discover tools
    const tools = await navigator.modelContext.getTools()
  2. 2Call the tool
    await tools.search_flights.execute({
  destination: "Tokyo",
  date: "2026-04-15",
  passengers: 1
})
2 clean steps. Typed inputs. Stable contract.

The Architecture

WebMCP does not replace web crawling. It adds a new layer on top. Here is how the pieces fit together:

Discovery

Manifest & JSON-LD

Sites publish a /.well-known/webmcp.json manifest and embed JSON-LD in the page. Agents find available tools before visiting.

Reading

Web Crawlers

Crawlers (Firecrawl, Jina, etc.) still index page content for search and context. WebMCP does not replace reading — it adds calling.

Using

WebMCP Tools

AI agents call navigator.modelContext.getTools() to discover tools, then invoke them with typed inputs. The site handles execution.

Testing

Our SDK

The WebMCP Registry SDK provides polyfill, validation, security scanning, conformance tests, and a CLI — everything to ship production-ready tools.

Try It Right Now

This very site uses the WebMCP Registry SDK. There are live tools registered on this page right now. Open DevTools and see for yourself:

// Open your browser DevTools console on this page and run:
const tools = await navigator.modelContext.getTools()
console.log(tools)

// You'll see the live tools registered by this docs site.
// This site dogfoods the WebMCP Registry SDK —
// the same SDK you'd install in your own app.

The navigator.modelContext API is provided by our polyfill today. When browsers ship native support, the polyfill steps aside automatically.

Ready to make your site agent-callable?

Get started in under 5 minutes. Works with React, Next.js, Vue, Angular, Svelte, or plain HTML.

Get StartedLive Demo