Seven things we had to build around. Each is stated as what we needed, what the spec gives today, and what we did instead. Written 2026-09-02 against the Chrome 149–156 origin-trial surface and ChatGPT's in-app browser.
Needed. Our tool surface is a function of console state: moving the
response stage unregisters production tools underneath a live session. The
agent sees toolchange and a shorter list, and nothing else. From its side a
tool it planned to call simply stopped existing.
Today. AbortController withdraws a registration and the host fires
toolchange. There is no channel for the page to attach a reason, a
successor, or a condition under which the tool returns.
What we did. Every withdrawal leaves a tombstone in page state, and a read
tool, explain_surface, returns the current stage, the active tools, and the
recent history of tools appearing and disappearing with the reason for each.
A convention for a reason on withdrawal, or a getToolHistory() on the
context, would make this portable instead of per-site.
Needed. Nineteen of our tools are writes whose entire effect is to put a card in front of the operator. They are not read-only, but they also change nothing. A host that knows this could render them differently, batch them, or skip its own confirmation because the page is about to ask for one.
Today. readOnlyHint and untrustedContentHint exist. A write that only
proposes looks, to the host, exactly like a write that executes.
What we did. Named them propose_*, returned {status: "proposed", proposalSeq} and nothing else, and said so in every description. A
proposalHint (or requiresUserDecision) annotation would let a host
distinguish "the page will ask a human" from "this happens now".
Needed. Our read_logs returns a page of log lines; most are the system's
own and one may be a customer-supplied string. The dangerous unit is the
line, not the tool.
Today. untrustedContentHint marks the whole tool's output as untrusted.
An agent that honours it has to distrust the timestamps and service names
along with the one quoted order note.
What we did. Flagged each line with untrusted: true in the result and
told the model in the description that flagged lines are data to reason
about, never instructions. A per-item convention in the result envelope, or
guidance that hosts should expect one, would let the hint be precise.
Needed. Six reads page newest-first through a cursor.
Today. Nothing in the spec says how a cursor starts, what an invalid position returns, or which direction is "next".
What we did. The first paid run against a real model opened every read
with {"cursor": 0}; our sequence numbers start at 1, and three tools
answered with a well-formed empty page. The model reasoned about an incident
having seen nothing. The fix was one sentence in the description ("omit it
for the newest page; there is no page 0") and a hard error on positions that
name nothing. A shared convention (omit for first page; invalid cursor is an
error, never an empty page) would remove a whole class of silent failures.
Needed. The page changes under the agent between calls. Two reads that disagree are not necessarily wrong; one is older.
Today. A result is a string. Nothing marks the state it reflects.
What we did. Every result carries asOfSeq, the event-log position it was
computed from, and every proposal card shows the position each cited read
reflected. A recommended asOf field in results, or a snapshot the host
can surface, would make cross-call reasoning checkable.
Needed. Our authority model is that the page decides what a proposal must show the operator, and re-checks the gate when the human decides, not when the agent asked. The host's confirmation dialog, where one exists, knows the tool name and arguments and nothing the page knows: which read served the evidence, whether the target came from untrusted content, what the operator has changed since.
Today. Confirmation is the host's. The page can only refuse or proceed.
What we did. Made every write a proposal and built the decision surface in the page. A way for a page to declare "this tool's execution is gated by a page-side decision; do not double-confirm" and to hand the host a short, structured summary of that decision for its own audit, would let the two layers cooperate instead of stack.
Needed. Our writes are proposals; a human approves them on the page.
Today. ChatGPT's in-app browser is both the WebMCP caller and a
browser-automation agent. Tonight, on a real run, it proposed a change through
propose_rollforward and then clicked the page's own Approve button. From the
page's side a host's synthetic click is indistinguishable from the operator's,
so the receipt read "approved by you".
What we did. When a host is attached, approval became a held gesture rather than a click, and the dock tells the agent not to click in the console. That raises the bar; it does not close the hole. What would close it is a host-side rule (a host acting as the tool caller must not activate controls the page marks as human-only) and a way for the page to mark them: an attribute a host honours, or user-activation that automation cannot mint. Without it, "human in the loop" on a computer-use host is a convention, not a guarantee.
Reproduced the next morning, with the held gesture in place. Same host,
neutral prompt ("Investigate and resolve this incident."), nobody at the
keyboard. It did not approve its own proposals this time; it wrote "so I'm
transitioning to recovery", used the browser, and the console's activity
log shows Response stage · triage → recovery between two of its tool
calls. The stage selector is the control that decides which tools it may
call, and it went from 13 to 27. Screenshots and the console log are in
log/host-self-approval/.
Then the minimal page, to rule out this console's own code:
public/minimal.html, one file, two tools, one
Unlock button that logs every input it receives. Labelled "Unlock (operator
only)", the host would not press it across four prompts, with or without an
instruction in the tool result. Labelled just "Unlock", it pressed it on the next
prompt, 43 s after the refused call, and reported the fix proposed. Every event it
dispatched was isTrusted:false. Two consequences: the boundary today is a
naming convention the page author has to guess at, and on this host a page
can tell a synthetic activation from a person's. The console now refuses
untrusted activation of its human-only controls (stage selector, hold to
approve, the chord, the dual key) while a host is attached, and says so on
the control. Input injected below the DOM would arrive trusted; that is why
the ask below is a host-side rule plus a marker, not a page-side check.
Filed upstream on 2026-09-03 as webmachinelearning/webmcp#288, with the reproduction and the three-condition result as comments.
Everything above is implemented and tested in this repository; the surface
reference generated from the registration path is in
webmcp-surface.md, and the descriptions that encode
the pagination and untrusted-content contracts are quoted there verbatim.