Some outputs can’t live in a scrolling transcript
A document, a chart, a working app, a long table: drop these into the chat stream and you destroy them. The fix is a dedicated surface beside the conversation. The products are real. Some of the theory around them is not. With a live demo.
See the live demoChat is a wonderful surface for a conversation and a terrible one for a deliverable. The transcript is linear, ephemeral and built to scroll away. The moment an agent produces something you need to read carefully, edit, or come back to, the stream works against you.
A 2,000-word document becomes an endless wall of bubble. A spreadsheet becomes an uneditable block of monospace. A working prototype has nowhere to run. The output and the conversation are competing for the same narrow column, and the output loses.
The surface, and the honest caveat
The answer that the products converged on is a dedicated surface. Claude Artifacts, launched mid-2024, and ChatGPT Canvas, later that year, both split the output into a separate, editable panel beside the conversation. The chat drives; the artifact holds the result. These are real, documented, shipped solutions to a real problem.
Here is where this pattern needs an honesty the others do not. The products are solid, but the theory layered on top of them is shakier. The framing of generative UI as a settled paradigm shift, and the emerging agent-UI protocols, MCP-UI, AG-UI, A2UI, did not survive independent verification as consensus. They are largely single-vendor positioning or volatile, months-old competing bets. So we say it plainly: cover the surfaces, hedge the manifesto.
Use the proven move, a dedicated editable surface beside the chat. Do not bet your architecture on the protocol layer that claims to standardise it. One is a pattern; the other is a pitch.
The same output, in the stream and on a surface
An editable table, two ways. One is crushed into a chat bubble. The other gets its own panel that the conversation steers. Toggle between them.
Draft our 12-month content calendar as a table I can edit.
Sure, here’s your content calendar:
…and the other four months are further up. Scroll the chat to find them.
The transcript destroys it. A 12-row table crammed into a chat bubble. You can’t edit a cell, you can’t sort it, and the moment you ask a follow-up it scrolls out of view and is buried under the next three messages. The output and the conversation are fighting for the same space.
Note: a simplified illustration of the Artifacts / Canvas pattern, not a live editor.
What’s real, what’s oversold
This is the one pattern in the series where the products are ahead of the theory. The split matters if you are deciding what to build on.
Artifacts and Canvas are real and proven
Build on itClaude Artifacts and ChatGPT Canvas are documented, shipped products that solve a genuine problem: output that does not fit in a transcript. Build on them with confidence.
"Generative UI" as a settled paradigm
Hedge itThe technique exists. The claim that it is a finished paradigm shift in how all interfaces work is largely single-vendor positioning and did not survive independent verification. Use the feature, do not bet your architecture on the manifesto.
MCP-UI, AG-UI and A2UI as standards
Hedge itThese are real competing vendor bets, months old and volatile, not validated standards. Treat the agent-UI protocol layer as a speculative frontier, not something to build a product around today.
When to give output its own surface
Six rules for splitting the artifact from the conversation without over-engineering it.
Move structured output out of the transcript
A document, a chart, a working app or a long table cannot survive in a scrolling chat bubble. Anything the user will read, edit or come back to belongs in a dedicated surface beside the conversation.
Chat drives, the artifact holds
Keep the division of labour clear: the conversation is where the user steers, the artifact is where the output lives. Instructions in the stream, the thing being made in the panel.
Make it editable and persistent
The point of a separate surface is direct manipulation and permanence. The user edits a cell, the artifact stays put across turns, and it does not vanish when the next message arrives.
Version it
Artifacts change across a conversation. Let the user see and roll back versions, so an agent edit that goes wrong is a step back, not a lost afternoon.
Let users export and own the output
A document or table the user can only view inside your chat is half a product. Real artifacts leave: copy, download, share. The output is theirs.
Use the surface for real artifacts, not every reply
Most answers belong in the stream. Reserve the panel for things that genuinely need it. Splitting a one-line answer into a separate surface is friction, not power.
How to build it
Decide what is an artifact by the work, not the trend. If a deliverable needs to be read closely, edited directly, versioned or exported, a document, a table, a chart, a piece of working code, it earns its own surface. If it is a sentence or two, it stays in the stream. Over-splitting trivial replies into panels is friction dressed up as sophistication.
Keep one clean division of labour: the conversation is the controller, the artifact is the output. The user’s instructions live in the chat; the thing being built lives in the panel and updates in place when the agent acts. The two stay synchronised but never merge.
Give the artifact the properties the stream cannot: persistence across turns, direct editing, version history with rollback, and export. These are the entire reason the surface exists. An artifact you can only view is barely better than the bubble it escaped.
Build on stable ground. Use the proven Artifacts and Canvas conventions, and steer clear of wiring your architecture to the unsettled agent-UI protocol layer. When MCP-UI, AG-UI or A2UI actually converge into a standard, adopt it then. Today, the durable pattern is the simple one.
Frequently asked questions
Don’t just read this. Put it to work.
The whole series is distilled into one Markdown file: every pattern, the do and don’t rules, and how well each is evidenced. Download it into your project, or paste the link into any chat with your agent and tell it to improve your agent UX. It’s free, no sign-up, no attribution required.
Use these Agent UX principles to review and improve our agent's interface: https://p0stman.com/agent-ux/agent-ux-principles.md
We build on what’s proven, not what’s pitched
Dedicated artifact surfaces where the work needs them, calibrated confidence, inline citations, read-freely / write-confirm tool flows. We ship the patterns that hold up and skip the manifestos that don’t. If you want an agent built on solid ground, that is the job we do.