An AI agent can build and publish a page from this site.

Real tools, not screenshot archaeology

The hard part of browser agents today is that the web was built for human eyes. An agent has to screenshot a page, infer what is clickable, and hope the layout did not move. WebMCP flips that: a site declares its actions as structured tools, with names, descriptions and JSON Schema inputs, and the agent calls them directly. It is the difference between guessing at pixels and calling a function. A publish primitive should be fluent in every protocol agents use to act, so we added WebMCP alongside our MCP server, REST API, and x402 rail.

What Stacktree exposes over WebMCP

The headline tool is stacktree_publish_html. It hits the same anonymous publish endpoint as our curl and CLI paths, so there is no new backend and no auth required.

It returns the live URL plus a single-use claim link, so a human can sign in later and keep the site permanently. Alongside it are read-only helpers: open the dashboard, view pricing, read the docs, and copy the install command. The same catalog drives the in-page ⌘K palette for humans, so an agent and a person learn the same verbs.

Register a WebMCP tool, in full

This is the actual shape, not a sketch. Removal is by aborting a signal you pass at registration; the shipped Chrome API has no unregisterTool.

function getModelContext() {
  const mc = document.modelContext ?? navigator.modelContext;
  return mc && typeof mc.registerTool === 'function' ? mc : null;
}

const mc = getModelContext();
if (mc) {
  const controller = new AbortController();
  mc.registerTool(
    {
      name: 'stacktree_publish_html',
      description: 'Publish an HTML page and get a live, shareable URL. No sign-in.',
      inputSchema: {
        type: 'object',
        properties: { html: { type: 'string', description: 'A complete HTML document.' } },
        required: ['html'],
      },
      async execute({ html }) {
        const fd = new FormData();
        fd.append('file', new Blob([html], { type: 'text/html' }), 'index.html');
        const res = await fetch('https://api.stacktr.ee/sites', { method: 'POST', body: fd });
        const out = await res.json();
        return { content: [{ type: 'text', text: JSON.stringify(out) }] };
      },
    },
    { signal: controller.signal },
  );
  // controller.abort() removes the tool.
}

Two ways to use it on stacktr.ee

Your agent calls the tools. Open stacktr.ee in a WebMCP-capable Chrome and your in-browser agent sees stacktree_publish_html and the rest, ready to call. It can generate a page and publish it without you touching the keyboard.

You drive it in plain English. Press ⌘K and the same palette runs a natural-language mode: describe a page (a coming-soon page, a one-pager, a manifesto) and a model generates a complete, considered HTML document and calls the publish tool for you. That mode is bring-your-own-key: your provider key is stored only in your browser and sent straight to the provider, never to Stacktree. The plain publish tool needs no key at all.

Is it safe to expose tools to agents?

WebMCP widens the prompt-injection surface in general, which Chrome itself has flagged, so the right discipline is a small, side-effect-light public tool set. Ours is exactly that: publishing is anonymous, unlisted, ephemeral and rate-limited, and everything else is read-only navigation. There are no destructive or account-mutating actions behind the public WebMCP surface. Account-scoped actions live in the signed-in dashboard, not on the open marketing site.

What is live, honestly

WebMCP is early, and pretending otherwise helps no one. The spec is a draft, and Chrome ships it behind an origin trial that runs through Chrome 156. Stacktree carries the origin-trial token, so the API is active for real visitors in supported Chromium browsers with no flag; everywhere else the registration is a harmless no-op. Most people's browsers cannot call our WebMCP tools yet, which is why the demo above is a recording. We shipped the surface anyway, for the same reason we published llms.txt, machine-readable pricing, and an x402 catalog before their consumers were everywhere: agent-readable surfaces compound, and day one of the standard landing is day one of it working here. Stacktree is one of the live examples in the WebMCP demos list maintained by GoogleChromeLabs, alongside the other sites shipping the API early.