Your agent, not our chatbot
A built-in assistant is a model you chose, a prompt you wrote and a bill you pay, sitting in the corner of a page the user is already looking at. This inverts it: the page declares its actions and the agent the user already trusts — in their browser, with their context — calls them. Nobody switches tools, and we do not run inference.
The browser half of a familiar idea
Mechanically it is the same shape as an MCP server: named tools with schemas and handlers. The differences are where it lives — registered on the document rather than served over a transport — and what it can reach: the session that is already open. No key exchange, because the page is already authenticated as you.
What the page registers
window.navigator?.modelContext?.registerTool?.({
name: "publish_html",
description: "Publish a document from this dashboard and return its share URL.",
inputSchema: { type: "object",
properties: { content: { type: "string" } },
required: ["content"] },
async execute({ content }) {
const r = await fetch("/api/sites", {
method: "POST", credentials: "same-origin",
headers: { "content-type": "application/json" },
body: JSON.stringify({ content })
});
return { content: [{ type: "text", text: (await r.json()).url }] };
}
});The same catalogue backs the command palette a human uses, so there is one implementation of each action rather than an agent path and a human path that drift.
Two doors, one implementation
That last point is the whole design. If the agent's tools are a separate code path they rot — nobody exercises them, and the day somebody does, the shapes have diverged. Registering the same handlers the interface calls means the agent path is exercised every time a person clicks the button.
Why the front page too, not just the app
Because the first useful thing an agent can do for a visitor is publish something, and requiring an account first defeats the demonstration. The homepage's paste box posts to the anonymous endpoint, so an agent that lands on the front page can produce a working link for its user with no credential at all.
Where the standard honestly stands
Early. The interface sits behind an optional namespace, availability varies by browser and by agent, and the shape may change. Which is exactly why the registration above is written defensively — optional chaining the whole way down, so a browser without it simply has a dashboard that works normally.
Why ship against something unfinished
Because the cost is a few dozen lines behind a feature check, and the alternative — waiting — teaches you nothing. If the shape changes, the handlers do not; they are the same functions the buttons call. The bet is small enough to lose.
What if the browser does not support it?
Nothing happens. Every call is optional-chained, so the dashboard behaves exactly as it does today and the human interface is untouched.
Is it safe to expose actions to any agent on the page?
The agent acts as the logged-in user and can do only what that user could do through the interface. The rule followed here is that no registered tool does something the visible interface does not also offer.
How is this different from the hosted MCP server?
Same idea, different reach. The hosted server is for agents anywhere, authenticated with a key or OAuth. This is for an agent already in the browser, using the session already open.
Can I try it?
Open /app with an agent-capable browser and ask it to publish something — or use the paste box on the homepage, which is the same endpoint with no account.