The landscape, one value at a time.
82 projects, products, protocols and ideas in seven clusters. Each has a dossier: what it is, the problem underneath, its bet, and what fictty should take from it. The radar shows how close each one sits to fictty, the map compares any two scores, and the board reads the clusters and their debates.
Relation to fictty (rings, inside out)
- 1adopt
- Speak it natively, as an input fictty accepts. (1)
- 2build-on
- A dependency fictty runs on or lifts code from. (2)
- 3complement
- Works beside fictty. Integrate, report status, ship recipes. (18)
- 4compete
- Does part of fictty's job for some of its users. Win on the claims or concede. (5)
- 5inspire
- Borrow the idea, not the code. (38)
- 6watch
- Not in the way today; could move toward fictty. (18)
Scores
- code vs data
- 0 the UI is code, 10 it is pure data
- ephemerality
- 0 a durable app, 10 made for one question and thrown away
- read-back
- 0 the agent can't see what's drawn, 10 exact state read back
- live data
- 0 frozen when written, 10 bound to live sources that skip the model
- learning
- 0 no bearing on understanding, 10 built to teach
- threat
- 0 to 5: how much of fictty's job it could take
- adopt fit
- 0 to 5: how well fictty could use it directly
fictty, scored the same way
Scored from the scope, as built today. Learning is low because nothing in fictty teaches yet; that's a direction, not a feature. Threat and fit don't apply to fictty itself.
The frame layer: window managers and agent multiplexers 11
The frame layer is about attention, not UI. People now run many long-lived coding agents across machines and worktrees, and these tools answer four questions: which agent needs me (per-pane status and an inbox), will it survive a disconnect or reboot (persistent sessions), can agents coordinate without me (socket APIs and CLIs for spawning, prompting and waiting), and where do I review (diffs, previews, PRs). There are two paths. Path A rebuilds the terminal multiplexer for agents: herdr (43k stars in six months), TUIOS, and the incumbents tmux and zellij, with Claude Squad as the first-wave ancestor. These run over SSH and own the PTYs, and what a pane shows is whatever program runs in it. Path B is the desktop agent workspace: the Codex app (inside the ChatGPT desktop app since 9 July 2026), Warp (client open-sourced 28 April 2026), cmux, Superset, Wave and Vibe Kanban (its company shut down in April 2026). These are steadily taking over the content layer with HTML or code: browsers you can comment on, Sites, MCP Apps, Pages, AI-written Go widgets. A status standard is emerging alongside: OSC 7501 (Rex/Superlogical; implemented by TUIOS, parsed by libghostty-vt), herdr's report-agent CLI, and OSC 9/99/777 notifications.
The debate, the verdict and the overview →TUIOS
A Go terminal window manager that knows what your agents are doing: tiling, persistent sessions, one Inbox for every agent on every machine.
For fictty Emit OSC 7501 (blocked:kind=question while waiting, done on close) so fictty screens appear in its Inbox; copy its error hint shape (did_you_mean, available, command) and --skill self-description; document tuios popup -- fictty run. Watch ask-human and dock components: they are the content layer starting inside the frame.
herdr
The runtime your coding agents live on: a Rust multiplexer with persistent sessions, multi-machine view, per-pane agent status and a socket API agents drive.
For fictty Ship a herdr plugin manifest that opens fictty as a popup or split, and call herdr pane report-agent --state blocked while a screen waits. Borrow snapshot plus subscribe with explicit events_lost for watch. Watch for declarative plugin UI: that would claim the content layer with huge distribution.
cmux
A native macOS terminal on libghostty with vertical tabs, notification rings and a scriptable browser pane for agents, plus a Rust TUI multiplexer.
For fictty Emit standard notification sequences (OSC 9/777) alongside OSC 7501 so a waiting fictty screen lights up cmux. Make get --state at least as convenient as an accessibility-tree snapshot with element refs, which is how agents read web UIs there.
zellij (plugins)
A terminal workspace with WASM plugins, host-drawn UI components, a full automation CLI and read-only web sharing.
For fictty Its host-drawn component protocol validates fictty's split between what and how, but it is reached through compiled code, has four components and is zellij-only. Use read-only web tokens as a zero-cost way to show a fictty screen to a group (teaching), model watch on subscribe --json, and make sure the cell fallback is clean (zellij has no kitty graphics).
tmux (control mode)
The default multiplexer and the substrate of nearly every agent screen driver; control mode lets another program be its client.
For fictty Document tmux new-pane -O -W -D 'fictty run ui.json' (modal, wait, Escape closes) as the way to ask a person something from inside tmux, after verifying the flags. Borrow format-subscription monitors as a model for watch, and make pixels degrade cleanly under tmux.
Wave Terminal
An Electron terminal whose window holds terminals, editors, browsers, previews and AI as blocks, controlled from the shell with wsh; AI-written Go widgets (Tsunami) are on the roadmap.
For fictty wsh view is the right gesture (one command opens a view beside the shell), so fictty should be as easy to place in every frame. Tsunami's go-build-per-edit plus screenshot check is exactly the cost fictty avoids with validated data and exact state read-back. Use that contrast in the post.
Superset
A desktop agent workspace (worktrees, terminals, diffs, browser Design mode) where every review surface sends feedback back to an agent, including commentable Pages.
For fictty Support feedback with context on nodes: select a row, attach a note, and watch delivers it to the agent with node id and value. Make the loop where the person comments and the agent patches by id a first-class demo.
Vibe Kanban
A local web kanban where issues become agent workspaces with diffs, previews and PRs; its company shut down in April 2026 and the project is community-maintained.
For fictty Frames are crowded and hard to monetise: 28k stars did not sustain a company. Keep fictty a small open runtime with no service to sustain, integrated into frames. A kanban view bound to gh issue list --json makes a good 'an app's main screen as one value' demo.
OpenAI Codex app
A desktop command centre for parallel Codex agents, now a mode of the ChatGPT desktop app, that keeps adding content surfaces: browser with comments, Sites, MCP Apps, inline visualizations.
For fictty The strongest evidence that agent work moves into desktop windows, and that GUI frames are eating the content layer through HTML. In the terminal nobody has done that yet, which is fictty's opening and may not last. Copy the comment-on-the-rendered-thing loop: notes attached to nodes, delivered through watch.
Warp
An agentic development environment born out of the terminal: block-structured output, its own agent plus third-party CLI agents, and Oz cloud orchestration; client open source since April 2026.
For fictty Blocks show that addressable units of output matter, and fictty's node ids are its version of that. Emit OSC 9/777 notifications so hosts like Warp surface waiting screens. warpui (MIT) is a reference only if fictty ever needs a native window.
terminal · frame · projectClaude Squad
A thin Go TUI that runs several local agents, each in a tmux session and git worktree, with a list, preview and diff review.
For fictty The list-preview-diff layout is the canonical supervision screen, so ship it as a fictty example bound to git worktree list and tmux list-sessions. A narrow tool gets absorbed by broader frames within a year, so fictty must stay a layer others build on.
Nothing in this cluster matches.
Terminal agent harnesses and the renderers under them 6
Terminal agent harnesses all rewrote or forked their renderers in the last 18 months: Claude Code moved off Ink to its own renderer and added a fullscreen mode with cell diffs. Codex draws with ratatui inline, sending history to native scrollback. opencode built OpenTUI (Zig core, Solid). Gemini CLI forked Ink and uses the alternate screen. Crush is on Bubble Tea v2 and Ultraviolet. pi built pi-tui, which diffs lines and wraps frames in synchronized output (DEC mode 2026). Flicker, scrollback and memory are now solved problems, but each team solved them separately. On the question of who else may draw inside the harness, they split three ways. Claude Code (mods, on by default since v2.1.287, 1 Oct 2026), opencode (TUI plugins, since March 2026) and pi (ctx.ui extensions) open their screens to third-party code: JS/TS returning element trees or lines, loaded as plugins. Codex and Google send rich visuals elsewhere. Codex writes HTML and opens it in a browser or the desktop app, and draws Mermaid as text. Google moved consumers from Gemini CLI to the closed Go Antigravity CLI, tied to a desktop app, on 19 May 2026. Crush and Gemini CLI let nobody draw. Two corrections to the first landscape post: Google's flagship terminal agent is now closed and tied to a desktop app, and pi (114k stars) belongs in the table.
The debate, the verdict and the overview →Codex CLI
OpenAI's Rust coding agent on ratatui, inline with native scrollback; visuals are HTML opened in a browser or the desktop app, plus a native Mermaid text renderer.
For fictty No UI runtime to adopt, and no place inside Codex for a live screen, so a fictty pane beside it fits. Vendor codex-mermaid (Apache-2.0) for a Mermaid diagram node; follow its 'refuse, don't half-draw' rule; consider an inline mode that keeps native scrollback; offer a file or URL fallback when a node can't render here.
terminal · harness · productCrush
Charm's Go coding agent on Bubble Tea v2 and Ultraviolet, with Bash-based config, Claude Code-compatible hooks, a local HTTP API, and native herdr status reporting.
For fictty No UI runtime to adopt, and Go buys fictty nothing. Copy the herdr client pattern: a small herdr-specific vocabulary (blocked when a screen waits on the person, working while data streams), then the same for TUIOS OSC 7501. Add a self-describing socket API (a describe verb) and a self-configuration skill.
terminal · harness · productClaude Code (renderer and mods)
Anthropic's coding agent, now with its own React renderer, a fullscreen cell-diff mode, and 'mods': plugin code that draws panes, a band and replaced rows inside the harness.
For fictty The strongest substitute for fictty among Claude Code users, and a possible host. Spike a Claude Code mod that renders a fictty UI value in a pane (degrading to Box/Text/Raster), with a screen tool for read-back, before Anthropic ships its own. Borrow render sites as named regions, polite focus (never grab keys while typing; wait for width), capability listing before run (claude plugin validate), and a stated redraw ceiling (theirs is 30/s).
terminal · harness · productopencode + OpenTUI
The most-starred open coding agent, client/server, on its own Zig-core TUI library (OpenTUI, Solid/React) with TUI plugins that add routes, dialogs and slot content.
For fictty Don't swap ratatui for OpenTUI: it means a JS runtime, another language and a pre-1.0 dependency for layout and widgets that taffy and ratatui already cover. Take named slots and routes as data-only ways to target regions and multiple screens, use attention.notify as the shape of a 'waiting for you' signal, ship fictty's docs as an installable skill, and note SSH serving. An opencode bridge plugin can come after the Claude Code one.
terminal · harness · projectpi (pi-tui)
A minimal, MIT, extension-first coding agent whose extensions can draw overlays, widgets and per-tool renderers through ctx.ui and its own line-diffing TUI library.
For fictty Add an awaitable screen ('fictty ask ui.json' blocks until submit and prints JSON), which is pi's ctx.ui.custom() over a socket and close to the planned watch. Consider tool-call renderers (hand fictty a JSON result, get a component), borrow the overlay anchoring vocabulary for layers, and emit synchronized output around every frame (fictty doesn't today). A pi bridge extension is possible later.
terminal · harness · productGemini CLI (and Antigravity CLI)
Google's open-source Ink-based terminal agent, demoted in May 2026 in favour of the closed Go Antigravity CLI tied to a desktop app.
For fictty Nothing to adopt. Correct the first post's 'all four labs ship their flagship as a terminal program': Google's is now closed and tied to a desktop app, which makes the question of whether the terminal is a phase concrete. Leave the last frame or a summary in scrollback on exit, keep mouse capture escapable, and remember that a lab's extension APIs can vanish.
Nothing in this cluster matches.
TUI frameworks fictty could build on or adopt 11
TUI frameworks solve how a developer writes a terminal app that ships. Their 2025–26 work was mostly renderers, because the streaming coding agents needed them. Bubble Tea v2 got the Cursed Renderer on Ultraviolet. OpenTUI is a Zig core under React and Solid, written for opencode. ratatui 0.30 split into modular crates and is what Codex draws with. Ink v8 added incremental line rendering, but Claude Code still replaced Ink's renderer with its own. I see six paths. (1) The Elm loop: Bubble Tea, tui-realm, Raxol and fictty. (2) React in the terminal: Ink, OpenTUI's bindings, iocraft. (3) The web's architecture in cells: Textual, with a DOM, CSS and a browser via textual-serve. Textual's company folded in 2025 and one person now maintains it. (4) A native core under a scripting API. (5) Specs over code: GitHub's TUIKit, where an LLM compiles Markdown specs into four frameworks. (6) One app on many surfaces: Textual-serve, Raxol to LiveView, SSH and MCP, Wish and OpenTUI over SSH, Ratzilla to WASM. Agents appear in these frameworks only as authors of code (OpenTUI ships an agent skill) and, newly, as status reporters. Bubble Tea v2.1 added OSC 7501 on 8 Oct 2026. That protocol is Superlogical's, written for its Rex terminal, not TUIOS's as our first post said.
The debate, the verdict and the overview →ratatui
Immediate-mode Rust TUI drawing library with a cell-buffer diff; fictty's current drawing layer.
For fictty Keep it: ratatui draws and fictty decides. Its immediate mode matches fictty's pure view and one-source-of-truth rule. Don't rewrite what it gives (layout, widgets, diff). Look at ratatui-image and tachyonfx before hand-writing more pixel or animation code, and keep state and view WASM-clean so Ratzilla can work later.
browser · renderer · libraryRatzilla
ratatui backends (DOM, canvas, WebGL2) that run ratatui apps in the browser via WebAssembly.
For fictty It's the cheapest browser surface for fictty: compile model, state and view to WASM and draw with DomBackend, replacing only runtime.rs. Enforce WASM-clean state and view now. Not yet verified: whether resvg and caretline build for wasm32.
terminal · framework · libraryBubble Tea v2
Go Elm-architecture TUI framework; v2 adds the Cursed Renderer, declarative views, modern keyboard input and OSC 7501 status.
For fictty Emit OSC 7501 when a screen waits on the person. Declare terminal modes (alt-screen, mouse, keyboard) in the UI value, as v2's tea.View does. Consider Wish-style SSH serving and teatest-style golden tests. Don't port to Go: it would mean rewriting everything and losing caretline and resvg.
terminal · framework · libraryInk
React renderer for the terminal with Yoga flexbox; used by Gemini CLI and Copilot CLI and the origin of Claude Code's UI.
For fictty Borrow three things: a linear screen-reader rendering of the UI value (done better, since fictty knows node roles), an inline non-alt-screen mode for short pickers, and flexbox vocabulary for sizing. Its line-based renderer is the weakest substrate for high-rate data. The closer competitor is json-render's Ink target, not Ink itself.
any · runtime · projectRaxol
Elixir/OTP TEA module rendered to terminal, LiveView, SSH and MCP tools derived from the live component tree.
For fictty Take its best idea and do it with data: generate MCP tools (click, select, type, read by node id) from the UI value, filtered to the focused region. Also take its test DSL in agent verbs and journal-based replay. Our first post overstated it: adoption is tiny and its scope is spread thin.
any · framework · libraryTextual (with textual-serve and Textual Web)
Python app framework with a DOM, CSS (TCSS) and a big widget set; textual-serve runs the same app in a browser.
For fictty Model the theme layer on TCSS-level expressiveness, but keep it as data. Model tests on Pilot and snapshot testing. Make streaming Markdown a primitive. For a browser surface, beat xterm.js streaming by rendering the UI value semantically or through Ratzilla. Python speed and the bus factor rule it out as a foundation.
terminal · format · projectTUIKit
Language-agnostic Markdown component specs that an LLM compiles into Bubble Tea, Ink, OpenTUI and ratatui code.
For fictty Take accessibility fields (role, announce) and behavioural tests into fictty primitives and project components, and use semantic tokens as the theme vocabulary. It's a signal that big players see terminal code as LLM-generated and disposable.
terminal · framework · librarytui-realm
Elm/React-inspired component framework on ratatui: components mounted by id, focus, event routing, input ports.
For fictty It's a reference for focus and state by id on ratatui, and its ports parallel fictty's data sources. Don't adopt it: its component state lives outside fictty's State, which breaks read-back and replay.
terminal · framework · libraryOpenTUI
Zig-core TUI library with TypeScript, React and Solid APIs, Yoga layout, images, SSH, embedded terminals and a headless test renderer.
For fictty It's the only alternative substrate worth revisiting, if fictty starts rebuilding its code, diff, markdown, image, SSH or embedded-terminal features. Copy the shape of its test API (renderOnce, captureCharFrame, mockInput) for a fictty library API. Add code, diff and markdown primitives, and ship an agent skill with the docs.
terminal · renderer · libraryNotcurses
C library treating the terminal as a compositor: z-ordered planes, pixels via kitty, sixel or framebuffer, and blitter fallbacks.
For fictty Use its blitter fallback ladder as the reference for fictty pixels on non-kitty terminals; ratatui 0.30's octant and sextant markers cover much of it. Detect capabilities once and expose them in get --state.
terminal · framework · libraryiocraft
React-style declarative Rust TUI and CLI crate with hooks and Taffy flexbox layout.
For fictty If fictty's layout moves toward flexbox or grid, compute it with Taffy on fictty's node tree and hand ratatui the Rects. Don't switch renderers.
Nothing in this cluster matches.
Agent-generated UI in the terminal: the closest neighbours 14
Agent-generated UI in the terminal splits into two groups. The first is about how an agent puts something in front of a person and gets an answer back. Projects take five paths. Prebuilt canvases: claude-canvas had about 1,500 stars within a week, then was abandoned as an unsupported proof of concept. A format plus a terminal renderer shipped as a library: json-render's Ink renderer, the Rust a2ui crate on ratatui, a2ui-ink and a2tea, so A2UI now renders in a terminal in three languages. UI drawn inline in the agent's own chat: a2tea's Crush fork and json-render's ink-chat example. A workspace the agent drives: Laura, which tiles panes of files, diffs and logs by pane id over a socket and returns the person's inline review to the chat. Code-first frameworks with an agent surface: Raxol derives MCP tools from its component tree, and Melker makes apps permissioned, readable documents. The second group is about how an agent uses a screen it didn't write. There has been a flood of near-identical PTY drivers in 2026 (tui-use, pilotty, two unrelated agent-tuis, agent-tty and others), alongside older MCP servers (tmux-mcp, iterm-mcp, terminalcp, ht), Microsoft's tui-test rewritten in Rust with Playwright-style locators, and VHS for recording. The best drivers try to recover structure: ConductorOne's agent-tui adds roles and refs through per-program adapters ("A terminal program is already a state machine. The problem is that the state is presented as a screen.").
The debate, the verdict and the overview →a2ui (Rust crate, ratatui)
A Rust implementation of A2UI v1.0 with a framework-agnostic core and a ratatui terminal backend covering all 18 basic components (plus six desktop backends).
For fictty A2UI on ratatui already exists, so an A2UI adapter is table stakes. fictty might borrow a2ui-base types or validation for its adapter, but should write the adapter as a translation onto its own value. Copy parse_and_fix (repair smart quotes and trailing commas, then report what changed) and test against the official spec examples.
terminal · renderer · libraryjson-render Ink renderer (@json-render/ink)
Vercel's catalogue-constrained JSON UI spec, rendered as an interactive terminal UI through Ink, streamed as RFC 6902 patches.
For fictty JSON UI in the terminal is not fictty's moat; json-render has it with real adoption. Accept json-render Ink-catalogue specs as input alongside A2UI and use RFC 6902 patches. Generate the agent skill from the catalogue as catalog.prompt() does, and borrow ink-chat's terminal design rules. Don't copy the expression language. Main risk: json-render ships an attachable terminal host.
terminal · harness · projectTerminal MCP servers and headless terminals (tmux-mcp, iterm-mcp, terminalcp, ht)
The first generation of 'let the model use a terminal': MCP tools over tmux panes or iTerm tabs, PTY process control with screen or stream reads, and ht's JSON-over-stdio headless terminal.
For fictty Keep fictty's MCP adapter thin with a short tool list; CLI plus skill comes first, as Zechner's benchmark suggests. Make headless screens attachable from any terminal, as terminalcp does. Consider a stdin/stdout JSON mode like ht's for hosts that can't open sockets.
terminal · harness · projectagent-tty (Coder)
A terminal an agent drives, with every session recorded and exportable as text snapshots, PNG screenshots, asciicasts or WebM, so a human can verify what it did.
For fictty Make fictty history exports double as PR proof: a .cast, a text transcript of frames and a picture, all exact because they are built from states. Add a doctor command that says what will degrade on this terminal.
tui-test (Microsoft)
Playwright for terminals, rewritten in Rust with CLI, Python, JS and Go bindings: locators, auto-retrying expects, cell and style reads, mouse and keys, recordings, and an agent skill.
For fictty Adopt it for emulator-level conformance tests: run fictty run in a real PTY and check that screen matches the emulator cell for cell, which render can't prove. Ship a fictty agent-context JSON command schema. Consider text locators (click --text) alongside ids.
tui-use (and the PTY-driver crowd: pilotty, pproenca/agent-tui, PTY-Agent, agentic-tui)
'Like BrowserUse, but for the terminal': run any program in a PTY behind a headless xterm, snapshot the screen as text, send keys, and wait for the screen to settle or a pattern to appear.
For fictty Generic screen-driving is a commodity; many clones appeared in 2026. fictty's value must be what only a state-owning runtime can do. Add wait-for-text or stable predicates to watch for agents that only know screen-driving, and mark selection explicitly in screen.
VHS (.tape)
Charm's terminal recorder: a small .tape script language replayed in a headless terminal to produce GIFs, videos, screenshots or text golden files.
For fictty Use it for the site's and README's demo captures. Model fictty's history export as a readable, editable, tape-like text (one line per input: key j, push ui.json, patch header). Replay of messages into state stays fictty's own, and exact.
terminal · runtime · projectLaura (laura-tui)
A TUI workspace that runs your agent CLI and gives it a socket API to tile panes of files, plans, diffs and logs, highlight and comment, with the person's inline review returned to the chat.
For fictty This is the closest loop to fictty in the terminal, but it shows documents, not components. Copy its agent ergonomics: post-push overflow and clipping reports, dry runs, holding writes while the person types, never-reused ids, and feedback pushed into the chat for agents that can't long-poll. It also names learning ('shows and explains concepts live') as a use case.
terminal · framework · libraryRaxol
An Elixir Elm-architecture runtime that renders one module to the terminal, LiveView, SSH and MCP tools derived automatically from the component tree.
For fictty Same architecture and read-back goal as fictty, but a developer writes the UI in code, so an agent can't conjure a screen. fictty's MCP adapter should derive semantic tools from the current UI value with a focus lens to keep the list short. Its headless test verbs should match the agent's verbs.
terminal · framework · libraryMelker
A Deno TUI framework where apps are readable .melker documents with a declared permission policy, run sandboxed and even from a URL.
For fictty Make a pushed UI's permissions visible data: list every command its sources and keys can run in get --state. Let the person approve once by hash, which makes the planned allow/ask/deny policy readable. Its serialised-tree-for-an-assistant also points at fictty's planned linear accessibility rendering.
terminal · harness · projectagent-tui (ConductorOne)
A PTY driver that exposes any terminal screen as an outline of regions with roles and stable refs (a 'DOM for terminal apps'), with waits on ref state.
For fictty The clearest outside statement of fictty's thesis; a screen that is data needs no adapter. Offer screen --outline in roles/refs vocabulary and write an agent-tui adapter that reads get --state, so driver users see fictty screens exactly. Support wait-on-ref-value predicates in watch, and quote the essay in the blog post.
claude-canvas
A Claude Code plugin that opens prebuilt Ink canvases (calendar, document, flight) in a tmux split and returns the person's selection over a Unix socket.
For fictty It proves the demand: an agent opens a screen beside itself and gets the answer back as JSON. fictty should ship an 'answer by pointing' example (meeting picker, seat map) as a UI value. Its watch should return selected/cancelled results, and it should offer a one-command 'open beside me' for tmux, herdr and TUIOS.
terminal · renderer · librarya2tea
A Go bridge that finds A2UI messages in a model's reply and renders them as embeddable Bubble Tea models inline in a chat host (a Crush fork).
For fictty Inline UI in the chat is the natural home for one-shot forms and pickers. If Crush or another major agent ships it, fictty's room narrows to screens that outlive a message (live dashboards, queues, walkthroughs). Keep render good for inline static snapshots, and default embedded chrome to monochrome so the host theme wins.
a2ui-ink
A community Ink renderer for A2UI v0.9/v0.9.1 on the official web_core message processor, covering all 18 basic components.
For fictty Use the official A2UI v0.9.1 examples as conformance fixtures for fictty's adapter. Once the adapter works, get fictty listed on a2ui.org's renderer page, which is where A2UI users look.
Nothing in this cluster matches.
The HTML camp: agents write pages 10
The HTML camp starts from one observation: a UI used to be expensive, so agents answered in text, and now a purpose-built interface costs one model turn. Its members bet that the model (or a developer) writes HTML/JS and a host renders it in a sandbox. The camp follows five paths. (1) The model writes the page and the host keeps it: Claude Artifacts, Claude Code Artifacts, Gemini dynamic view and AI Mode generative UI, and the short Imagine with Claude demo. (2) The developer writes a reviewed template and the model only calls it: MCP Apps/MCP-UI and the OpenAI Apps SDK, which converged on MCP Apps in February 2026. (3) The model writes code against a fixed catalogue: Cursor Canvas's component library, and Claude's Slides/Docs/Design/Dashboards templates from September 2026. (4) A local review loop around agent HTML: Lavish, with element-level annotations and a long poll. (5) The model writes durable apps: v0. Under all of them sit three problems. Text flattens spatial and interactive information. People increasingly use generated UI to understand things (explainers, module maps, simulations; Google's research found raters strongly preferred generated pages to text, speed aside). And a page the person can't answer through is only a broadcast, so 2026 was the year of return paths: Artifact comments sent to a watching Claude session, Lavish's poll, MCP Apps' update-model-context, ChatGPT widget state.
The debate, the verdict and the overview →Claude Code Artifacts
Claude Code publishes an agent-written HTML page to a live, versioned, shareable claude.ai URL that it can keep updating, take comments on, and feed with connector data.
For fictty Cede share-and-keep entirely: add an HTML export so a fictty screen can graduate to an Artifact. Treat its comment-to-Claude watch loop as the minimum bar for fictty's watch. Copy declared capabilities: data-source commands should be declared and reviewable. Compete only on local live sources, exact frame read-back, terminal/SSH and agent neutrality.
chat · format · protocolMCP Apps (SEP-1865) and MCP-UI
The official MCP extension that lets a tool ship a predeclared HTML UI, which hosts render in a sandboxed iframe and talk to over MCP JSON-RPC.
For fictty No terminal renderer, so fictty can't adopt it as its surface. It should borrow the vocabulary (tool-input/result, display modes, declared CSP as a model for declaring command scope) and expose fictty itself as an MCP server. A small HTML renderer could later show a fictty UI value as an MCP App.
browser · idea · essay"HTML is the new markdown" (The unreasonable effectiveness of HTML)
An essay and 20-example gallery arguing agents should write self-contained HTML instead of Markdown for any non-trivial output.
For fictty It is the strongest counter-argument to terminal screens, yet its twenty examples reduce to a handful of recurring shapes, which argues for a catalogue. Rebuild the gallery as fictty recipes: what works becomes a demo, and what fails marks the terminal's real limit. Replace 'paste the result back' with read-back and watch.
chat · harness · productClaude Artifacts (claude.ai)
The chat-side original: substantial outputs open beside the conversation as runnable, shareable artifacts, now with viewer-billed AI, connectors, storage and typed templates.
For fictty The lab's own move to typed templates supports data-over-code for common shapes. Name fictty's recipes as discoverably as Slides/Docs/Dashboards, and plan for personal versus shared state once several people or agents watch a screen.
native · harness · productCursor Canvas
Cursor's agent answers with a persistent, rerunnable canvas of sections, stats, tables and charts built from a first-party component library, shareable as a live snapshot.
For fictty It is commercial evidence that 'agent fills a known catalogue' beats free-form pages for recurring shapes. Keep the query, not the result: make refresh/rerun explicit and show data age. Ship recipes as skills, and make sure stat tiles and sections are first-class.
browser · harness · projectLavish (lavish-axi) and AXI
A local CLI and browser editor where a person annotates an agent's HTML file and the agent collects that feedback with a long poll, then revises.
For fictty Lavish's loop is the nearest thing to fictty's in the browser. Make watch a long poll that returns structured, node-id-anchored feedback, with explicit ended states. Add point-at-a-node notes, delivery receipts and layout warnings reported to the agent, and follow AXI for the CLI. Interoperate (export a screen to HTML for Lavish) rather than rebuilding annotation.
chat · harness · productGemini generative UI (dynamic view, visual layout, AI Mode)
Gemini answers a prompt with a custom interactive HTML page built per question, in the Gemini app and Search AI Mode.
For fictty It is the best published evidence for the learning thesis, and its latency caveat (up to a minute) is fictty's opening. Borrow post-processing as validate-and-repair of pushed UI values. Build explainer recipes, and measure time to first useful frame, the number Google left out.
browser · idea · researchImagine with Claude
A five-day research preview in which Claude generated software on the fly on a virtual desktop, with each click producing the next piece of interface.
For fictty It is the clearest argument for fictty's split by contrast: putting the model in the per-click loop is why it stayed a demo. The agent should generate screens and a runtime should own behaviour. Use 'agent generates the next screen' as a benchmark where only changed nodes are patched.
chat · framework · productChatGPT Canvas and Apps SDK
OpenAI dropped its model-written side panel (Canvas) from current models and bet on developer-built widgets in ChatGPT via the Apps SDK, now an MCP Apps host.
For fictty The Canvas reversal is a data point: heavy surfaces should be summoned, not default, so fictty should teach agents when not to open a screen. Borrow the model-visible versus UI-only split (a compact model view in get --state) and the display-mode names.
browser · harness · productv0
An app-building agent that turns a prompt or repo into a working web app with a live preview and one-click deploy, now with a GA headless API.
For fictty Mostly a reference point for what fictty is not (durable apps). Two small lessons: make watch and history typed events, and possibly offer a 'describe this screen as an app spec' graduation export. Low priority.
Nothing in this cluster matches.
The data camp: agents fill in declarative UI 8
The data camp is solving one problem: letting a model put interactive UI in front of a person without the host running code the model wrote. Every entry uses server-driven UI. The host keeps a catalogue of trusted components and draws them its own way, and the model sends a description. Adaptive Cards did this for bots in 2017. A2UI, json-render, OpenUI, ChatKit widgets and Tambo redo it for agents under three new pressures: streaming (flat lists with ids, or JSON Patch lines, so a half-sent UI still draws), tokens (OpenUI's terse language, and A2UI's Express proposal following it), and editing over several turns (everything addressable by id or name). The paths split five ways. A2UI and Adaptive Cards bet on a portable format where the host owns the look. json-render is a toolkit that treats formats as catalogues and has many renderers, including the only real terminal one (Ink). OpenUI is a compact language with variables, logic and model-free data queries, plus a paid gateway. AG-UI and CopilotKit own the transport and shared state and stay neutral on format. The AI SDK, ChatKit and Tambo follow "model picks, developer renders". Almost everything lives in a browser chat and treats the UI as a message, not a standing screen.
The debate, the verdict and the overview →A2UI (Agent-to-User Interface)
A streaming JSON format for agent-described UI that each client renders with its own native widgets from a trusted catalogue.
For fictty Keep fictty's own value internal and write the A2UI v1.0 input adapter onto assembly. Align vocabulary (surface, catalogue, data model, pointer) so the mapping is lossless. Copy the split between structure and data in the patch verbs, structured validation errors that carry a JSON Pointer, placeholders for missing references, and sendDataModel-style state attached to actions in watch. A2UI has no data sources, key maps, layers, pixels, theme or read-back, so it can't be fictty's internal model.
browser · runtime · protocolAG-UI and CopilotKit
An event protocol between agent backends and user-facing apps (runs, messages, tool calls, shared state as JSON Patch), with CopilotKit as the frontend stack on top.
For fictty It is a transport, not a UI, so there's nothing to adopt in its place. It could be a second wire protocol for fictty. Emitting state as a snapshot plus RFC 6902 deltas from get --state and watch would let AG-UI tooling consume fictty unchanged. Use CopilotKit's controlled/declarative/open-ended taxonomy to explain where fictty sits.
any · renderer · libraryjson-render
A schema-agnostic generative UI toolkit: Zod catalogues, flat JSON specs streamed as JSON Patch, and renderers from React to PDF to the terminal (Ink).
For fictty It is the nearest terminal neighbour (the Ink renderer) but it's a library inside someone's app, with no socket, patch-by-id from outside, local data sources or read-back. Adopt RFC 6902 (plus RFC 7396 merge) as fictty's patch dialect, generate agent-facing docs from the same schema the runtime validates, and state fictty's no-logic rule clearly against json-render's growing expression set. Watch for json-render/ink gaining a socket and read-back; that would erode fictty's lead.
browser · format · libraryOpenUI (Thesys; C1 now OpenUI Cloud)
A compact, streaming-first UI language (OpenUI Lang) with reactive variables, expressions and runtime-executed data queries, plus a commercial cloud and gateway.
For fictty It can't be adopted: it is a programming language, which breaks fictty's data-never-code rule, and it has no terminal runtime. Its Query(tool, args, default, refreshSeconds) is the nearest cousin to fictty's data sources, so copy the default value that renders before the first result and the re-run when a bound input changes. Publish token counts for fictty examples against A2UI and json-render. Argue the no-logic stance explicitly.
any · format · protocolAdaptive Cards
Microsoft's 2017 JSON card format: declarative UI snippets rendered natively by each host under a host config, with templating and fallback.
For fictty Too small for fictty's screens (no tables with selection, no patch by id, no live binding), so don't adopt it. Take host config (the theme owns the look, and the agent says 'emphasis'), fallback for unknown components (a labelled placeholder instead of a failed push), and a version field in every pushed UI.
chat · renderer · productOpenAI ChatKit widgets (and Open-JSON-UI)
A drop-in chat UI whose widgets are designer-made templates (a strict JSX dialect, .widget files with Jinja placeholders) hydrated with data and streamed into a conversation.
For fictty Nothing to adopt: it is a vendor-hosted web component with no public standalone schema and no terminal story. Take the plain-text twin per node, a per-node copy text in get --state that lets an agent quote one card without parsing the frame. The template-plus-data split already matches fictty's project components.
browser · framework · libraryTambo
A React generative UI SDK and backend where agents pick registered components and keep editing 'interactable' ones; its hosted cloud is shutting down.
For fictty Interactable components back up the idea of an agent continuously editing a live screen. Every fictty node already works this way (patch by id, read back), and the docs should say so. The shutdown is a warning against building a hosted agent loop: stay the runtime that the terminal agent talks to.
browser · framework · libraryVercel AI SDK generative UI
Generative UI as typed tool calls whose results a React chat renders with developer-built components.
For fictty It is the baseline pattern most agent developers learn: the model picks, the developer renders. fictty's project components are its terminal equivalent and should be at least as easy to use as writing a full UI value. The streamUI retreat supports fictty's data-never-code stance.
Nothing in this cluster matches.
Ideas: disposable UI, malleable software, and learning by seeing 22
For forty years a UI was durable and costly: a team built it once and many people used it. In 2025 and 2026 it became something a model writes in a minute for one person and one question. This cluster covers the responses, which split into eight paths. (1) Malleable and home-cooked software (Ink & Switch, Sloan, Appleton) says regenerating apps is not the goal. People need to adapt and compose durable tools over shared data, and "AI code generation alone does not address all the barriers". (2) Per-prompt generated UI (Google Generative UI, Claude inline visuals): the labs' default is HTML written per answer and thrown away. Google's raters preferred it to markdown 83 to 91% of the time, with a wait of a minute or more hidden from them. Anthropic now draws a line in its product between permanent Artifacts and "temporary" visuals built "to aid understanding". (3) Catalogues (ChatGPT's roughly 70 concept modules, which is our inference; NotebookLM's fixed formats; Gemini's retrieved diagrams and quizzes): where correctness matters, labs pick fixed formats that the model fills in. (4) Instruments for understanding (Geoffrey Litt): when agents write the code, understanding is the bottleneck, and HUDs beat copilots. His examples are a one-minute custom debugger, a migration command center, and an explainer with a quiz. (5) The explorable-explanation craft (Victor, Case, Distill, manim) was right but too costly to author: Distill stopped in 2021 after editors spent 50+ hours on single articles. Agents now cut that cost, though generated visuals still have layout errors. (6) Reactive notebooks driven by agents (Observable, marimo pair). marimo pair puts the agent inside a live kernel where it reads values back exactly, which is the closest loop to fictty's. (7) Tutors, mostly in text. The evidence says behaviour design matters more than the model or the medium: Bastani found unguarded help harms learning, Kestin found a guarded tutor can beat a class, and Khanmigo's two-year trial shows 0.04 SD. Learning science backs relevant pictures plus words (g=0.37) and simulations for transfer. It warns that decorative visuals hurt and rejects "visual learners". No study tests a generated interactive screen against a text tutor. (8) The medium fight: Ptacek argues cheap UI means native apps, not TUIs. The replies point to remote use, Jane Street's finding that text snapshots make agents better at UI, and joshka's semantic-protocol idea, which Ptacek himself calls the strongest rebuttal.
The debate, the verdict and the overview →Claude learning mode and Claude Code Learning/Explanatory styles
Socratic mode in Claude, and Claude Code output styles that add insights or leave TODO(human) exercises in the code.
For fictty Ship a 'teach' skill pairing with these styles: walkthrough screens for insights, and a TODO(human) screen bound to live test status that waits via watch. Becomes a competitor if Anthropic brings visuals to Claude Code.
chat · renderer · productClaude inline visuals
Claude builds temporary interactive HTML visuals inline mid-conversation, explicitly distinct from permanent Artifacts.
For fictty Adopt the durable-vs-temporary vocabulary; push screens unprompted when they help; compete only where HTML visuals can't reach: live data from commands, frame-rate interaction, exact read-back of what the person did, remote terminals.
native · idea · essayStop Making TUIs (Thomas Ptacek)
Agents made native GUIs nearly free, so build CLIs and native apps, not TUIs.
For fictty Concede durable apps; his remote pattern (CLI on prod driven by a local UI) is fictty's socket architecture, so a local renderer of a remote screen answers him; keep the UI model semantic and independent of cells so it can move to a New Terminal or GUI.
chat · renderer · productChatGPT study mode and interactive math/science visuals
Socratic study mode plus about 70 interactive concept visuals where you change variables and watch graphs update.
For fictty The catalogue path is what a lab chose where correctness matters most; fictty recipes (formula + parameters + plot bound to a computed source) are the terminal equivalent.
n/a · idea · essayMalleable software (Ink & Switch)
Essay arguing people should adapt and compose their tools over shared data, not wait for vendors or regenerate apps.
For fictty Give people a gentle slope to tweak a pushed screen without regenerating it; keep data sources separate from screens so tools share data; use its scepticism of regenerate-everything as the case for a stable editable representation.
browser · idea · essayOn-demand instruments and AI HUDs (Geoffrey Litt)
Have the agent build a throwaway instrument (debugger, command center, explainer with quiz) so you understand, instead of asking it to fix things.
For fictty Make 'instrument' (step-through, scrubber, side-by-side) fictty's headline use case; quizzes and checkpoints need read-back via watch; expose history/seek as a UI component. Must beat 'ask for an HTML page' on live data, remote and read-back.
terminal · idea · essayThe replies: TUI renaissance, Bonsai_term, semantic terminal protocol
The pro-terminal case: remote and keyboard use, Elm-style Bonsai_term whose text snapshots help agents, and a call for a semantics-not-cells protocol.
For fictty Cite Jane Street as outside evidence that text read-back makes agents better at UI; engage joshka with fictty's semantic UI value as a working example; document render --keys as snapshot tests for agent-pushed screens.
any · renderer · library3Blue1Brown and manim (and agents writing manim)
Python engine for programmatic math animation, now a target for agents generating explainer videos.
For fictty Layout errors dominate generated visuals; built-in layout in components avoids that bug class. Show transitions between bound states as steps (animate the data).
n/a · idea · essayAn app can be a home-cooked meal (Robin Sloan)
The founding essay of home-cooked software: a family messaging app with four users and zero churn.
For fictty Separate 'for few people' from 'for a short time' in our writing; provide a path from a pushed screen to a saved, reopened one, since some will be kept.
browser · idea · projectDistill
Peer-reviewed interactive ML journal that went on hiatus because interactive articles cost too much to make.
For fictty Use '50 hours per diagram vs one push' to state the cost collapse; quality needs a floor the runtime's components provide, since there are no editors.
n/a · idea · researchDual coding, multimedia learning and the learning-styles myth
The evidence that words plus relevant pictures beat words alone, moderately, and that 'visual learners' is a myth.
For fictty Claim the multimedia principle, not learning styles; coherence (no decorative elements) and contiguity (callouts on the node) are design rules for generated screens; manipulable simulations have the better transfer evidence.
n/a · idea · researchEvidence on AI tutors (Bastani, Kestin, Oreopoulos)
Unguarded AI help harms learning, a well-designed tutor can beat a class, and real deployments show small effects.
For fictty Teaching screens must make the person act (predict, choose, answer) and never just show the solution; a small study of text tutor vs tutor-plus-screen on a developer task would be new evidence, cheap with exact read-back logging.
browser · idea · essayExplorable Explanations and Dynamicland (Bret Victor)
The essay that named reactive documents and explorable examples: text as an environment to think in.
For fictty Add named parameters that bound sources depend on (the reactive document in fictty terms); teaching screens are guided walkthroughs with layers, not free dashboards; test value by whether the person can change an assumption and see the consequence.
n/a · idea · essayHome-cooked software and barefoot developers (Maggie Appleton)
Talk arguing LLMs could let 'barefoot developers' build local community software, if someone supplies the glue.
For fictty The glue is the product: a runtime that draws, binds data and runs behaviour is what makes generated UIs usable. Keep the format plain data a non-programmer can read and edit.
chat · idea · productKhanmigo (Khan Academy)
Socratic text tutor inside Khan Academy exercises; a two-year RCT found 0.04 SD, about the same as practice without AI.
For fictty Engagement, not explanation quality, limited the best-funded tutor; screens should make the next action obvious and log exactly what the person did. Don't claim unmeasured learning gains.
browser · idea · researchLearn Your Way (Google Research)
Turns a textbook chapter into personalised text, narrated slides, mind maps and quizzes; beat a PDF reader on delayed recall in a small RCT.
For fictty Retrieval practice (quizzes with read-back) is the best-evidenced ingredient; one data source shown as several views is a natural fictty demo; generate screens from the real artefact, not model recollection.
browser · idea · projectNicky Case's explorables
Hand-built playable explanations of systems (Parable of the Polygons, The Evolution of Trust).
For fictty Predict-then-reveal with the guess read back (prompt node + watch); narration plus one control beats a dashboard of controls.
browser · idea · productNotebookLM (Google)
Source-grounded study tool that turns your documents into audio and video overviews, mind maps, quizzes and reports.
For fictty Every number on a teaching screen should trace to its source (show the command behind a bound value); a navigable tree-with-detail component is worth having.
browser · idea · researchGenerative UI (Google Research)
Gemini writes a custom interactive HTML page per prompt; raters prefer it to markdown when the wait is hidden.
For fictty Preference was measured with speed hidden and without comprehension; publish fictty's time-to-useful-screen and run a small pairwise study that adds a comprehension question. Keep the format small enough that valid means renders.
browser · framework · librarymarimo and marimo pair
Reactive Python notebook as a .py file; marimo pair lets Claude Code or Codex act inside the live kernel and read values back.
For fictty Keep agents acting on the live screen, with files as save/load; return per-node health after a patch; distribute as an installable agent skill.
chat · idea · productGemini Guided Learning (Google)
Step-by-step Socratic mode in Gemini with retrieved diagrams, images, videos, quizzes and flashcards.
For fictty Quizzes are the cheap, evidenced part; prefer found visuals (existing diagrams, command-produced charts) over generated ones.
browser · framework · productObservable (notebooks, Framework, Notebooks 2.0)
Reactive JavaScript notebooks with D3/Plot, now an open HTML file format plus a desktop app.
For fictty Dependency-driven updates from parameters are the missing piece for reactive teaching screens; if people edit saved screens, consider a friendlier authoring surface while keeping JSON canonical.
Nothing in this cluster matches.