AgentPing / WebMCP

Every Website,
Agent-Ready

The WebMCP Shim — Greasemonkey for the AI Age

Turn any website into a structured tool API your AI agent can call.
No scraping. No screenshots. No browser restart.

40x cheaper per step
<100ms tool call latency
0 screenshots needed

AI agents are blind on the open web

Every agent framework hits the same wall: the web was built for humans with eyeballs, not machines with token budgets.

2,000 tokens per screenshot

Agents waste context on pixels

Every screenshot eats 2,000+ tokens of context window. A 5-step workflow burns 10,000 tokens just looking at pages — before the agent even reasons about them. That is money and latency set on fire.

Cloudflare blocks headless browsers

The cookie extraction ceremony

Headless Chrome gets blocked instantly. So you export cookies, inject them into Playwright, pray the session holds, and restart when it doesn't. A five-minute task becomes a thirty-minute ritual.

DOM changes break everything

Selectors rot overnight

CSS selectors are a bet against every deploy. One class rename, one React key change, and your entire automation is dead. Agents built on selectors are inherently fragile.

Three layers. Zero scraping.

The WebMCP Shim sits inside your real browser — past Cloudflare, with your auth, speaking structured tool calls instead of pixel coordinates.

2

Tool Definitions

Community-contributed .webmcp.yaml per site — declarative tool schemas that map semantic actions to DOM operations.

1

WebMCP Shim

navigator.modelContext polyfill injected by the extension — exposes a structured tool API on every page.

0

AgentPing Extension

Runs in your real browser. Past Cloudflare. With your cookies. Human-approved, lease-gated, time-bounded.

# slack.webmcp.yaml
name: slack
version: 1.0.0
match: "*.slack.com/*"

tools:
  send_message:
    description: "Send a message to the current channel"
    params:
      text: { type: string, required: true }
    action:
      selector: "[data-qa='message_input']"
      steps: [focus, clear, type, submit]

  read_messages:
    description: "Read recent messages from the current channel"
    params:
      limit: { type: number, default: 10 }
    returns: Message[]

Declare once. Every surface. Every transport.

Lev's Poly architecture generates every surface from a single handler declaration. One function becomes a CLI command, an MCP tool, an HTTP endpoint, and a WebMCP tool definition.

One Handler Declaration

Poly generates every surface automatically

>_

CLI Command

lev send_message

◊

MCP Tool

callTool("send_message")

⊕

WebMCP Tool

.webmcp.yaml definition

# config.yaml — one declaration, every surface
poly:
  surfaces:
    - id: send_message
      resolves_to: chatgpt/send_message
    - id: switch_model
      resolves_to: chatgpt/switch_model

FlowMind Engine

Multi-step workflows become tool sequences. Deterministic execution with rollback at every stage.

Graph DNA

Constraints enforce safety at compile time. Every tool surface inherits the system's invariants.

Three steps. Fifty tokens.

1

Extension injects the polyfill

The AgentPing extension injects the WebMCP shim into every page you visit, exposing navigator.modelContext as a structured API surface.

// Extension content script navigator.modelContext = new WebMCPShim(); shim.loadTools("chatgpt.webmcp.yaml");
2

Tool definitions load from registry

Matching .webmcp.yaml definitions are loaded from the community registry (or auto-generated on the fly via agentic crawling).

tools: - name: send_message params: { text: string } - name: switch_model params: { model: string }
3

Agent calls structured tools

Your agent calls semantic tools directly. No vision model. No coordinate math. Just clean function calls.

// 50 tokens. Instant. await agent.callTool("send_message", { text: "Deploy approved. Ship it." }); // Returns structured data, not pixels const msgs = await agent.callTool("read_messages", { limit: 5 });

The numbers speak for themselves

Before: Screenshot Scraping After: WebMCP Shim (Read) GenUI (Write)
Token cost ~2,000 / step ~50 / step 40x ~100 / component
Speed 3–5 seconds <100ms <200ms
What it does Reads pixels from page Reads structured data Generates UI in-page
Cloudflare Blocked Passes Passes
Auth Cookie extraction ceremony Inherits browser session Inherits browser session
AI required? Yes (LLM interprets screenshots) No (structured tool calls) Yes (LLM generates components)

Like Greasemonkey scripts, but for AI agents

A growing registry of community-contributed tool definitions. One YAML file per site. Version-controlled. Fork-friendly.

Community-Contributed

Open contribution model

Anyone can submit a .webmcp.yaml for any site. Review, fork, and improve — just like userscripts, but with schema validation and semantic versioning.

Auto-Generated

Agentic crawling

No YAML for a site yet? The extension can auto-generate tool definitions by crawling the page structure. AI writes the tool schema so you don't have to.

Version-Controlled

Pinned and reproducible

Lock to a specific version. Roll back when sites change. CI-testable definitions ensure your agent workflows stay green across deploys.

Native Handoff

Graceful deferral to native WebMCP

When browsers ship native navigator.modelContext, the shim detects it and steps aside. Your tool definitions keep working. Zero migration cost.

Read. Write. Control.

The WebMCP Shim is direction one. GenUI and CDP complete the picture — turning the browser into a full bidirectional agent interface.

Read

WebMCP

WebMCP Shim

Agent reads structured data from any website through semantic tool calls.

callTool("get_messages")
~50 tokens / call
Write

GenUI

Generative UI

Agent generates and injects UI components directly into the page.

renderComponent("chart", data)
~100 tokens / component
Control

CDP

Chrome DevTools Protocol

Agent manipulates the DOM directly through the browser's native debug interface.

click(@e3)
~50 tokens / action

The browser becomes a full bidirectional agent interface.

This is not a pitch deck. This is running code.

The foundation is live. The WebMCP Shim extends an already-operational agent-browser bridge.

AgentPing Browser Extension

WXT/MV3 architecture. Chrome Web Store ready. chrome.debugger CDP bridge for agent-to-browser communication.

Lease-Gated Security Model

Human approves every agent session. Scoped access per domain. Time-bounded leases that auto-expire. No ambient authority.

CDP Command Pipeline

Agent → daemon → extension → browser tab. Full round-trip with structured responses. No screenshots in the loop.

Cookie Extraction Engine

20+ services mapped. Non-destructive extraction from your live browser session. No headless browser required.

5-Tier Browser Cascade

dev-browser → PinchTab → agent-browser → browser-use → Skyvern. Automatic fallback through increasingly powerful tiers.

416 UI Components Migrated

Full component library on @kingly/ui. Storybook green. DTS green. The interface layer is production-ready.

Poly MCP Surface

Every handler is an MCP tool. One declaration generates CLI, HTTP, and MCP surfaces automatically via Poly.

FlowMind Engine

Deterministic workflow execution. Multi-step tool sequences with rollback, state tracking, and session management.

The web wasn't built for AI.
We're making it native.

One shim. Every website. Every agent.