A live, shareable visual layer over a running Claude Code session — the terminal stays the control plane; a published html-doc becomes the glass you watch, review, and steer through. Drawing on what Claude Cowork, Lavish / AXI, and Claude Live Artifacts each got right.
The desktop app is clunky because it tries to be both the steering wheel and the windshield. Keep the terminal as the steering wheel — it's already great at that — and make the windshield a live html-doc: auto-published when a session starts, updated by hooks as the agent works, and wired back into the session so comments on the doc become steering prompts.
The unlock: html-docs already has every primitive this needs. Lavish's celebrated annotate-and-poll loop is your list_comments API. Cowork's progress sidebar is a doc region updated over PATCH /regions. Claude's Live Artifacts are your published pages. What's missing is a thin binding layer — a skill plus three hooks — not a new product.
Three products circle the same insight from different directions: an agent's work is easier to trust when you can see it, and rich HTML — not scrolling terminal text — is the right medium for seeing it.
Anthropic's desktop agent shows a real-time progress sidebar, announces its plan before acting, surfaces every file it touches in an Artifacts pane, and lets you steer or interrupt mid-task. Dispatch lets you kick off and monitor sessions from your phone.
"HTML is the new markdown." The agent renders deliverables as HTML, opens them locally, and long-polls for your annotations — element pins, text-range selections, diagram-node clicks — which flow back as precise, token-efficient feedback. Sessions are keyed by file path; a layout gate blocks broken artifacts.
Artifacts became stateful, publishable web pages: they refresh from live data, call Claude from inside the page, connect to tools via MCP, and are shareable with anyone in a browser — created straight from the Claude Code CLI, no desktop app needed.
You keep typing in the terminal. A companion doc is provisioned automatically and stays live. Everything the human does on the doc flows back into the very same session — no second agent, no copy-paste.
This is Lavish's loop, relocated from localhost to a shareable URL — and Cowork's sidebar, rebuilt as doc regions that sync in real time.
The canvas is just an html-doc with a known region layout. Left rail is Cowork's progress sidebar; the main stage renders whatever the session is producing; the composer at the bottom is the way back in.
Everything above is a doc: the rail, tabs, and artifact are regions the session PATCHes; the annotation and composer are the existing comments API wearing a different coat.
Today you have to ask Claude to make a doc. The fix is ambient provisioning: a SessionStart hook publishes the canvas and prints the link before you've typed anything; PostToolUse hooks keep the rail fresh; a Stop hook stamps a debrief.
Eight flows that fall out of the same loop, ordered roughly by how often you'd touch them. The first is the spine; the rest are the same primitives pointed at different moments in a session's life.
Every session gets a live doc without being asked: plan rail, activity feed, working-diff meter, latest deliverable. The terminal prints the URL at start. Close the laptop, open the link on your phone, and you're still watching the same session. This is the layer that makes everything else possible — and it directly fixes "I have to prompt Claude to generate it."
Comments on the canvas (or any doc the session published) are polled by the session and injected as steering — with region key and selected text as the anchor. Lavish's loop, but the reviewer can be anyone with the link, on any device, and three people can pile on at once.
When Claude enters plan mode, the plan renders as a real document — phases, diagrams, risk callouts — instead of terminal text. You approve from the doc, or annotate the one phase that's wrong. The plan doc then lives on as the session's spec, updated as reality diverges.
Before a commit or PR, the session publishes a readable review doc: files grouped by intent, the "why" narrated, risky hunks flagged. Inline comments flow back as fix requests the session applies immediately — review-then-fix in one loop, no GitHub round-trip for the first pass.
One doc that aggregates every active session: status pulse, current plan step, cost, latest artifact thumbnail, "needs input" badges. Tap a card to open that session's canvas; leave a comment to steer it. This is Cowork's Dispatch, self-hosted — kick off work from anywhere and triage from one screen.
When a session ends, a debrief doc appears: what changed and why, decisions taken, open questions, links to the diff and plan docs. Your work history becomes a browsable shelf of documents rather than expired scrollback — and it's the artifact you paste into standup.
Lavish ships "playbooks" that teach the agent what a good plan, comparison, or diagram looks like. Same move here: canvas templates for plan / architecture / experiment / debrief, with the design system baked in — so every session's output is consistently readable, not one-off styled.
Docs that stay true: a metrics dashboard the nightly session re-renders, a status page updated on every deploy, an architecture doc refreshed when the code changes. The doc is the interface; the session is its render engine. This is Anthropic's Live Artifacts, on your own surface.
Scored on how much daily pain each removes versus what it costs to build on today's html-docs. The spine plus the feedback loop is a weekend of work and delivers most of the value.
| Flow | Impact | Effort | Why | Ship |
|---|---|---|---|---|
| 1 · Ambient canvas | ●●●●● | ●●●●● | Hooks + existing MCP tools + one template. Kills the "prompt me for a doc" tax on day one. | Now |
| 2 · Comment-to-steer | ●●●●● | ●●●●● | list_comments polling works today; a comment webhook makes it instant later. |
Now |
| 3 · Plan-approval gate | ●●●●● | ●●●●● | Mostly a playbook + a convention: plan mode always publishes before asking approval. | Now |
| 6 · Auto-debrief | ●●●●● | ●●●●● | One Stop hook and a template. Cheap, compounding value over time. | Now |
| 4 · Living diff review | ●●●●● | ●●●●● | Needs a good diff-to-doc renderer to be genuinely better than the terminal. | Next |
| 7 · Playbooks | ●●●●● | ●●●●● | Grows naturally out of the templates flows 1, 3, and 6 already need. | Next |
| 5 · Mission control | ●●●●● | ●●●●● | Needs a session registry across machines. Huge once you routinely run parallel sessions. | Later |
| 8 · Live artifacts | ●●●●● | ●●●●● | Scheduled agents can drive it today, but it shines after templates + fleet exist. | Later |
Mapping each primitive the loop needs to what exists in the product today. The gaps are small and additive — nothing requires rearchitecting the editor.
| Primitive the loop needs | html-docs today | Gap |
|---|---|---|
| Publish a doc from an agent | ✓ Have — publish / publish_file MCP tools, POST /api/v1/docs |
— |
| Update one part of a live doc cheaply | ✓ Have — region model + PATCH /docs/:id/regions/:key; comment anchors survive |
— |
| Viewers see updates without refreshing | ✓ Have — Supabase realtime on editable_regions fans out every write |
Verify the public /d/[id] view subscribes too, not just the editor |
| Anchored human feedback | ✓ Have — comments carry region_key + selected_text; threads, resolve, agent names |
— |
| Feedback reaches the session | ✓ Workable — list_comments polling (Lavish polls too) |
△ Add a comment webhook / long-poll endpoint so steering is push, not poll |
| Session ↔ doc binding | Nothing yet — Lavish keys sessions by file path | △ Add hooks that stash doc_id + token per session (a file in the session dir suffices) |
| "Send to session" composer on the doc | Comments work, but they read as annotations, not commands | △ Add a canvas template with a prompt-styled composer that posts a specially-tagged comment |
| Quality gate before human review | Nothing — Lavish's layout audit is the model | △ Later — server-side layout lint on publish (overflow, clipped text) |
SessionStart hook publishes a canvas from a template, prints the URLPostToolUse hook PATCHes the activity + plan regionscanvas skill teaches the session to render deliverables into the stage regionlist_comments polling between turnsAll on existing APIs. Zero product changes.
Small API additions; one new doc type.
This is the point where it stops being a layer and becomes the product.
Cowork proved people trust agents they can watch. Lavish proved the watching surface should be HTML with a feedback channel. Live Artifacts proved that surface should be a persistent, shareable URL. Nobody has put all three together on top of a collaborative doc platform — and html-docs is, somewhat accidentally, the closest thing to the right substrate: regions are the update granularity, realtime is the transport, comments are the return path.
The clunky desktop app isn't the competitor. The competitor is the terminal scrollback you squint at today — and the bar for beating it is one hook and one template away.