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
- Render surfaces for things the user manipulates while talking to the model.
- Publish anything with a reader who is not in the conversation.
- Do not treat a rendered surface as durable — the session ends, and so does it.
- Keep the markup identical across both paths, so what they forward matches what they saw.
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.