◈OpenTree DashboardSign in

$ date -I # 2026-07-25

Agent clients render HTML now. That is only half of a publish story.

The extension that lets an MCP server return a rendered interface rather than text is a real change in what a tool call can be. It also makes the gap it does not close more obvious: something rendered inside a client is not something you can forward.

What it standardises

A tool result can carry an HTML surface, which the client displays in a sandboxed frame with a defined channel back to the server. Before, every assistant that wanted this invented its own format; now there is one shape, and a server that emits it works in more than one client.

Why HTML won this

Because it is the only format that renders everywhere without a build step and degrades to text when it cannot render. Every alternative — a widget schema, a component DSL — requires the client to implement a vocabulary. HTML requires the client to already be a browser, which it is.

The lifecycle of a rendered surface

The server returns markup; the client renders it in an isolated frame; the frame may call back to the server; the result updates. The isolation is the important part, and it is why these surfaces are constrained: no ambient credentials, no reach into the surrounding page, a narrow message channel. That is correct — and it is also why they cannot be the deliverable.

Where the HTML lives, and where it does not

It lives in the conversation. It does not live at a URL. Nothing to bookmark, nothing to forward to a colleague who is not in the client, nothing to open on a phone, nothing to gate, and nothing that survives the session being cleared. For an interactive control surface that is fine. For a deliverable it is disqualifying.

Out of scope, deliberately

The extension does not attempt hosting, persistence, sharing or access control, and it should not — those are a different problem with different failure modes. Which means the complete story for a server that produces something a human keeps is two verbs: render it here, publish it there.

The other half

// render in-client, for the interaction
return { content: [{ type: "text", text: summary }], _meta: { ui: html } };

// publish, for the artifact
const site = await publish_html({ content: html, expires_in: "7d" });
return { content: [{ type: "text", text: site.url }] };

Same markup, two destinations, different jobs. The first is where the user works; the second is what they send to somebody who was not there.

If you maintain a server

Where this deployment sits

On the publishing side, entirely. It takes markup and returns an addressable, gateable, expiring URL. The rendered-surface half belongs to the client — the two compose, and the composition is the useful part.

Can I forward a rendered surface to a colleague?

Not as a link — it exists inside a client session. Publishing the same markup gives you something forwardable, which is the composition this post is about.

Is the sandbox strict?

Deliberately. No ambient credentials, and a narrow channel back to the server. Treat it as hostile territory for anything that needs secrets.

Does this replace a hosted page?

No. It replaces a paragraph describing what a page would have shown, which is a real improvement over that and not the same thing as a URL.

What does this deployment return?

A URL. Twelve tools, none of which render an interface — publishing is the whole job here.

Keep reading