Intent Relay

• 

  Intent mapped to Orbit’s WebMCP capabilities: 5 preserved, 2 adapted, 1 not transferable, 1 sent to Human Queue.

• 

  A provenance-backed Intent Contract proposed from the demonstration, with every rule reviewed and approved by the human.

• 

  Orbit’s draft is prepared, but publication stays human-only: the agent can prepare; only the human can publish.

What it is

Most WebMCP demos ask what an agent can do on one site. Intent Relay asks what happens to human intent across sites.

Intent Relay does not replay clicks. It translates human intent across the web: a human demonstrates a workflow once on a WebMCP-enabled site, reviews what that demonstration means, and carries the approved intent to a structurally different site.

How it works

The Workbench orchestrates two embedded demonstration providers built for this prototype — Gather (source) and Orbit (destination). They are separate HTTPS origins that structure the same job differently, on purpose.

1. Demonstrate. You set up an event in Gather the way you always would. Gather exposes semantic state through WebMCP, and the trace records what each choice means — not where you clicked.
2. Verify. From that demonstration, the agent side proposes an Intent Contract: rules with provenance, each citing the recorded actions that justify it. Nothing counts until you approve it — rule by rule.
3. Transfer. Intent Relay discovers the capabilities Orbit exposes through WebMCP and maps your approved intent against them. The canonical demo result:
   • 5 preserved — transfer unchanged
   • 2 adapted — a 24-hour reminder becomes "1 day", because that's how Orbit counts
   • 1 not transferable — Orbit has no equivalent, so it is excluded visibly, never silently
   • 1 needs your decision — genuinely ambiguous
4. Human Queue. The ambiguous one stops here: the demonstration used a native waitlist; Orbit doesn't have one. The agent doesn't guess — you decide, and only then does it prepare Orbit's draft. The Human Queue is a feature, not a failure state.
5. Publish. Publication is deliberately not exposed as a WebMCP tool. The prepared draft waits for a human. The agent can prepare; only the human can publish.

Why WebMCP matters here

Traditional browser automation can repeat actions on one interface, but it is brittle the moment two sites expose different structures and concepts. Intent Relay depends on what WebMCP makes possible: websites publishing machine-readable capabilities instead of an agent scraping DOM structure or replaying screen coordinates.

• Real browser-discovered tools via document.modelContext across three origins (Workbench, Gather, Orbit)
• Cross-origin semantic capability discovery — Orbit declares what it accepts, and mapping decisions are driven by those declarations
• Deployed to production through the Chrome Origin Trial — the demo runs in normal Chrome without WebMCPTesting flags
• Explicit human boundaries: contract approval, ambiguity decisions, and publication are human-only

Challenges we ran into

• Cross-origin discovered tool objects. Real DiscoveredTool objects carry cross-origin WindowProxy references that cannot safely live in React state — the implementation separates sanitized display metadata from the raw browser handles used for invocation.
• Representing semantic mismatch without guessing. Every approved rule must land in exactly one explicit status (preserved / adapted / not transferable / needs decision) — "almost matches" is a first-class outcome, not an error path.
• Origin Trial across three origins. Three distinct HTTPS origins each needed correct Origin Trial configuration to run flag-free in production.

What we learned

WebMCP solves capability exposure — semantic equivalence between sites still needs reasoning and explicit boundaries. The most interesting case is not when two sites match perfectly, but when they almost match: that is exactly where human judgment matters most, and where an agent that refuses to guess is more useful than one that automates blindly.

How it's built

React + TypeScript + Vite in npm workspaces (three apps plus shared packages for contract types, validation and mapping logic), WebMCP via document.modelContext, three HTTPS origins on Cloudflare Pages behind the Chrome Origin Trial, 241 unit tests and a Playwright end-to-end suite, plus runtime validation in real Chrome.

What's next (future work)

More WebMCP-enabled providers; richer Intent Contract schemas; portable workflows across marketplaces, productivity and travel tools; shared semantic vocabularies; deeper provenance and policy handling. None of this exists yet — the prototype intentionally proves the transfer model on two deliberately different providers.

Built With

• cloudflare-pages
• playwright
• react
• typescript
• vite
• webmcp