Imagine entering a restaurant where there is no menu.
To order lunch, you must walk into the kitchen, inspect every shelf, understand how the appliances work, and guess which ingredients belong together.
That is roughly how AI agents use most websites today.
When you ask an agent to search for a product, compare offers, fill out a form, or press a button, it often has to:
- inspect the page;
- understand thousands of DOM or accessibility-tree elements;
- find the right control;
- build a selector;
- guess which input it expects;
- repeat the process when the page changes.
It works, but it is expensive, fragile, and unnecessarily complicated.
WebMCP offers a better idea: give the agent a menu.
What is WebMCP?
WebMCP allows a website to expose structured tools directly to an AI agent.
Instead of interpreting the entire page, the agent can see capabilities such as:
search_products({ query })
filter_offers({ condition })
add_offer_to_cart({ index })
submit_contact_form({ fields })
Each tool tells the agent:
- what it does;
- what input it accepts;
- what risk it carries;
- what structured result it returns.
The problem is that manually adding tools to every page, form, filter, and button still takes work.
That is why I built Universal WebMCP Runtime.
WebMCP without the integration work
Universal WebMCP Runtime examines the interface your website already has and automatically turns it into a compact WebMCP tool catalog.
Install it:
npm install @gr3p/universal-webmcp
Then start the runtime:
import { createWebMCPRuntime } from '@gr3p/universal-webmcp';
const runtime = createWebMCPRuntime({
mode: 'hybrid',
confirmationPolicy: 'risk-based',
});
runtime.start();
The runtime discovers forms, buttons, navigation, filters, lists, and repeated actions. It generates names, descriptions, and input schemas, removes redundant tools, and registers the useful capabilities with WebMCP.
Your website remains usable exactly as before. WebMCP becomes a progressive enhancement for agents.
Why this matters for website owners
Without a shared tool layer, every agent must reverse-engineer your interface independently.
With Universal WebMCP:
- you do not need a separate agent-specific API;
- your existing UI remains the source of truth;
- the current browser session, permissions, and validation continue to apply;
- tools update when a dynamic page changes;
- open shadow roots and same-origin frames are covered;
- developers can override ambiguous discoveries with simple HTML metadata.
Integrate the runtime once, and compatible agents can immediately understand what your website allows them to do.
Why this matters for people using agents
Agents spend a surprising amount of context simply understanding webpages.
In our public live benchmark, collecting the same 25 offers required:
| Representation | Tokens |
|---|---|
| Relevant HTML | 245,375 |
| Targeted ARIA snapshot | 10,187 |
| Selected WebMCP tool, input, and result | 1,332 |
| WebMCP result with a cached catalog | 1,041 |
The selected WebMCP path used:
- 99.5% fewer tokens than the relevant HTML;
- 86.9% fewer tokens than the ARIA snapshot.
More importantly, the agent did not have to rediscover how the page worked.
It received a structured tool, invoked it, and got structured data back.
That means less browsing, fewer screenshots, fewer broken selectors, and fewer reasoning steps.
Is automatic discovery safe?
A useful agent interface should not expose every clickable element without context.
Universal WebMCP includes:
- deterministic semantic identities;
- confidence thresholds;
- catalog limits;
- risk classification;
- confirmation policies;
- allowlists;
- filtering of hidden and sensitive controls;
- stronger classification for destructive actions.
Actions still go through the visible interface, existing browser session, and application validation.
The runtime does not read cookies, bypass authentication, defeat CAPTCHAs, or reverse-engineer private APIs.
The honest limitation
Sending the complete tool catalog on every request is not always cheaper than sending a small accessibility snapshot.
The advantage comes from selecting the relevant tool and caching the catalog. In our benchmarks, WebMCP became cheaper than repeated ARIA inspection from the second task.
This is not magic compression. It is a better operating model for agents.
The web already has interfaces for humans. Now it needs interfaces for agents.
Websites use HTML and ARIA to explain their structure to browsers and assistive technologies.
WebMCP can become the corresponding capability layer for AI agents.
Universal WebMCP makes that transition practical for existing websites:
Existing website
↓
Universal WebMCP Runtime
↓
Structured WebMCP tools
↓
Any compatible AI agent
Website owners should not have to rebuild their applications for every new agent.
Agents should not have to reverse-engineer every website they visit.
They should meet in the middle through a small, structured, and safe tool layer.
That is what Universal WebMCP Runtime provides.
Stop making agents reverse-engineer websites. Give them tools.
Top comments (0)