What we're building, and what we're not

Hover a column for its rubric, a cell for the reason behind the score. Click a header to sort.

Not counting scene. Where someone else scores higher, that's where scene is reinventing, or should borrow.

What to take, tool by tool

• Bubble Tea: v2's declarative View struct for terminal modes (alt screen, mouse, keyboard flags, cursor) as fields in scene's JSON root
• Bubble Tea: Program.Send semantics: external messages enter the same queue as keys
• Bubble Tea: teatest-style golden frames for scene tests
• Bubble Tea: VHS tape format as inspiration for scripted, recordable tours
• Bubble Tea: OSC 7501 program status as a cheap way to tell the host terminal what scene is doing
• Ink: <Static>/inline mode: an optional non-fullscreen scene mode that keeps native scrollback
• Ink: ink-testing-library's lastFrame()/frames[] as the shape of scene's screen readback
• Ink: React DevTools' live prop editing as a model for patch-by-id UX
• Ink: Interop: accept the same JSON A2UI/json-render emit to Ink
• Textual: Pilot's verbs (press, click(selector, offset), hover, pause/wait-for-idle) as the shape of scene's key/mouse ops
• Textual: CSS-selector addressing in addition to plain ids for patch/click
• Textual: SVG screenshot export of the cell frame for docs and readback
• Textual: textual serve's idea: the same scene served to a browser
• Ratatui (+ ratatui-image): Render scene's JSON nodes into ratatui widgets/Buffer rather than a private renderer
• Ratatui (+ ratatui-image): TestBackend-style in-memory buffer as the 'screen' op's source of truth
• Ratatui (+ ratatui-image): ratatui-image's Picker (font-size + protocol query) and halfblock fallback for scene's pixel layer
• OpenTUI: #1506/#1525 lesson: below-cell-background kitty z-indices break where apps paint cell backgrounds and in some hosts (cmux); scene's 'cards beneath text' layer needs a probe and a fallback z
• OpenTUI: Protocol resolution order auto→kitty→sixel→blocks and an env override (OPENTUI_IMAGE_PROTOCOL)
• OpenTUI: captureSpans() (styled spans, not just text) as a richer screen-readback format
• OpenTUI: Split-footer scrollback mode as an alternative to fullscreen
• OpenTUI: Shipping docs as an agent skill
• Notcurses: The blitter ladder (pixel → octant/sextant/quadrant/half-block/braille) as scene's pixel fallback
• Notcurses: 'Assume the maximum and step down' only on positive terminal confirmation (it won't use bitmaps unless the terminal says so)
• Notcurses: Planes/piles as a mental model for scene's callout and card layers
• Notcurses: notcurses-demo-style per-terminal benchmark methodology
• iocraft: Inline (non-fullscreen) render mode and print-once mode for one-shot scene output
• iocraft: taffy as a flexbox engine if scene needs richer layout
• Vercel AI SDK generative UI (RSC streamUI, AI SDK UI, @ai-sdk/tui): runAgentTUI's display modes (full/collapsed/auto-collapsed/hidden) for tool and reasoning sections
• Vercel AI SDK generative UI (RSC streamUI, AI SDK UI, @ai-sdk/tui): ChatTransport abstraction: run local agent or attach to remote one
• json-render: RFC 6902 JSON Patch as scene's patch op (or an accepted alternative) so SpecStream output can drive scene
• json-render: catalog.prompt(): generate the agent's system prompt from scene's component schema
• json-render: Expression vocabulary ($state, $bindState, $cond, $template) as a compatibility layer
• json-render: Devtools-style action and patch log as the seed of scene's time-travel UI
• json-render: Publish a json-render catalog that targets scene components
• A2UI (Agent-to-User Interface): Accept A2UI v0.9.1/v1.0 JSONL (createSurface/updateComponents/updateDataModel/deleteSurface) as an input adapter mapped onto scene components
• A2UI (Agent-to-User Interface): Catalog negotiation (catalogId) to advertise which components scene renders
• A2UI (Agent-to-User Interface): sendDataModel-style data model echo on actions
• A2UI (Agent-to-User Interface): application/a2ui+json MIME type for MCP resources
• A2UI (Agent-to-User Interface): Treat agent-pushed specs as data-only (no command data sources) unless a local policy allows
• AG-UI + CopilotKit: Consume AG-UI event streams so any AG-UI agent (ADK, LangGraph, Mastra...) can drive a scene
• AG-UI + CopilotKit: STATE_SNAPSHOT/STATE_DELTA semantics for scene's data model
• AG-UI + CopilotKit: parentRunId-style lineage for scene's fork/replay
• AG-UI + CopilotKit: Event compaction (collapse deltas into snapshots) for scene history export
• Thesys C1 (now OpenUI Cloud) and OpenUI: A compact text form for agent-written scenes to cut tokens (the token benchmark is a useful yardstick)
• Thesys C1 (now OpenUI Cloud) and OpenUI: Prompt generation from the component library
• MCP Apps (SEP-1865): Expose scene as an MCP server (push/patch/keys/screen/state tools) so any MCP agent can drive it
• MCP Apps (SEP-1865): Use the fka.dev extension shape: advertise a terminal-view resource next to HTML, negotiate catalogs in initialize capabilities
• MCP Apps (SEP-1865): ui/update-model-context pattern: let the UI push a compact state summary to the model
• MCP Apps (SEP-1865): CSP/predeclared-resource idea as a template for scene's command allowlist policy
• tldraw SDK + Agent starter kit: Focused/Blurry/Peripheral context levels for scene's `state`/`screen` readback to keep tokens low
• tldraw SDK + Agent starter kit: History marks with names plus bailToMark/squashToMark and record/preserveRedo/ignore modes (agent cursor moves = ignore)
• tldraw SDK + Agent starter kit: Modes as data: per-mode lists of what the agent sees (parts) and can do (actions)
• tldraw SDK + Agent starter kit: Streamed incremental application of agent actions so the human watches the agent work
• tldraw SDK + Agent starter kit: Lints passed to the model (overlaps, truncated labels) as a readback channel
• Wave Terminal: A small CLI (`wsh`-style) that works from any shell, including over SSH, as the agent's control surface alongside the socket/MCP
• Wave Terminal: Badges/notify on panes for agent attention (Claude Code hooks)
• Wave Terminal: `blocks list --json` style discovery of live scene instances and their ids
• Wave Terminal: getmeta/setmeta as a generic id-addressed property patch
• Phoenix LiveView: Static/dynamic split for scene templates: precompute static structure once, re-evaluate only bindings whose inputs changed
• Phoenix LiveView: Streams semantics (insert/delete/reset by dom id with limits) for large live lists
• Phoenix LiveView: PubSub-style topics for data sources so many scene views share one producer
• Phoenix LiveView: A LiveViewTest-like headless driver API for scene (render, element(selector) |> click, assert)
• Excalidraw MCP (official MCP App + community mcp_excalidraw): A read_me / guide tool that returns the format cheat-sheet before first use
• Excalidraw MCP (official MCP App + community mcp_excalidraw): Checkpoint ids returned from every push so the agent can say 'start from checkpoint X, delete ids a,b, add these' instead of resending
• Excalidraw MCP (official MCP App + community mcp_excalidraw): describe_scene: a compact text description (ids, positions, labels, connections) distinct from the raw screen
• Excalidraw MCP (official MCP App + community mcp_excalidraw): query_elements by type/bbox/filter for addressing scene nodes
• Excalidraw MCP (official MCP App + community mcp_excalidraw): Named snapshots save/list/restore as a stopgap before full time travel
• Claude Canvas: An awaitable high-level call (e.g. scene.ask(ui) -> {selected, data} | {cancelled}) for approvals and pickers
• Claude Canvas: Ship the agent integration as a Claude Code plugin/skill with a marketplace entry
• Claude Canvas: Spawn into a tmux/herdr split automatically when available
• PTY/TUI screen drivers for agents (agent-tui and peers): wait_for_idle / wait_for_text / wait --ref primitives for agents (scene can implement them exactly from its own state instead of polling pixels)
• PTY/TUI screen drivers for agents (agent-tui and peers): ConductorOne's ref grammar and CSS-subset selectors (@app.role[value=x]) for addressing scene nodes
• PTY/TUI screen drivers for agents (agent-tui and peers): read_region and scrollback ops on scene's screen
• PTY/TUI screen drivers for agents (agent-tui and peers): asciicast export of a scene session for sharing
• PTY/TUI screen drivers for agents (agent-tui and peers): A monitor TUI listing live sessions with attach (tui-mcp monitor)
• Raxol: Focus lens: limit exposed agent actions to the focused/hovered/modal region (~15 tools) plus a discover_tools meta-tool
• Raxol: Derive semantic MCP tools per component kind (click, type_into, select_row, seek) from scene's JSON nodes
• Raxol: Time-travel entry shape {index, message, changed} and diff output {changed|added|removed, path, old, new}
• Raxol: Authorizer returning allow | ask | deny, deny-by-default in production, refuse to boot a network transport without a configured policy
• Raxol: Structured screenshot: strip callbacks/styles, return {type,id,role,label,value,focused,children} alongside text
• Raxol: MCP test harness API (start_session |> type_into |> click |> assert_component)
• LangGraph time travel: Checkpoint = {id, parent_id, values, next, metadata}; history listed newest-first; every checkpoint addressable.
• LangGraph time travel: Fork never mutates: update_state on a past point writes a new child checkpoint; the original timeline stays intact.
• LangGraph time travel: as_node: record who/what produced a forked change (scene: agent, user, data source) and resume accordingly.
• LangGraph time travel: Explicit, documented replay semantics for effects (scene: data-source commands re-run vs replayed from the log; default to the log).
• LangGraph time travel: Same verbs across library, REST and frontend hook (forkFrom) — scene: socket ops, MCP tools and TUI keys share one model.
• rrweb: Event envelope {type, data, timestamp} with Meta (terminal size, theme, capabilities) + FullSnapshot + Incremental (patch, key, mouse, resize, data-source update) + Custom (agent narration, marks).
• rrweb: checkoutEveryNth / checkoutEveryNms: periodic full snapshots for seek and retention windows.
• rrweb: Skip-inactive and speed controls for replays and tours.
• rrweb: Masking options at capture time (e.g. mark nodes or data sources as private, never exported).
• rrweb: liveMode: the same replayer consumes a live stream, which gives scene 'watch an agent/learner live' for free.
• rrweb: A plugin hook on record and replay.
• Redux DevTools: Model history as a lifted reducer: history ops are messages (JUMP_TO_ACTION, TOGGLE_ACTION, COMMIT, IMPORT_STATE…) applied by a pure function, so they replay and test like everything else.
• Redux DevTools: stagedActionIds + skippedActionIds + minInvalidatedStateIndex: skip/reorder by recomputing from the first invalidated index.
• Redux DevTools: maxAge + COMMIT: bounded window with old messages folded into a committed base state.
• Redux DevTools: lock: suppress effects (data-source commands, exec) while the cursor is in the past.
• Redux DevTools: features flags per surface (e.g. export-only for untrusted agents).
• Redux DevTools: Test generation from a selected message range (scene: emit a replay test from a history slice).
• Rerun: Store UI config (scene's pushed UI) as a timeline of its own, so undo/redo of agent pushes and patches is a cursor move and edits drop the redo tail (BlueprintUndoState).
• Rerun: Inflection-point heuristic to collapse bursts (slider drags, streaming patches) into single undo points.
• Rerun: get_viewer_state shape: list every view/component with the warnings/errors it reported last frame, so the agent learns why something is empty without a screenshot.
• Rerun: Append recent log lines to every tool result.
• Rerun: Two tool families: generated high-level ops from one proto/schema first, raw key/mouse as fallback.
• Rerun: highlight_rect semantics: one pulsing highlight at a time, dismissed by the user's click.
• Rerun: Multiple timelines (message index, wall time, data-source tick) with a cursor per view.
• Replay.io: One universal address for moments (Replay: execution point; scene: message index / tx id) returned by every history call and accepted by every inspection call.
• Replay.io: Tool modes: summary first, then detail, to keep agent context small.
• Replay.io: GetPointLink: a human-openable link/command that opens the UI at the exact moment the agent is discussing.
• Replay.io: Dependency chain ('why did this change'): scene can answer it exactly from its message log — which message and data-source update produced a node's value.
• Replay.io: Retroactive logpoints analogue: evaluate a template/query against the state at every past message.
• Elm time-travel debugger: Snapshot every N messages (Elm uses 31) and seek by replaying from the nearest snapshot.
• Elm time-travel debugger: Export = metadata (program/format version + message schema) + message list; validate the schema on import and explain incompatibilities in plain words.
• Elm time-travel debugger: Decide explicitly what an export omits (Elm omits model, effects, flags) — scene should include its initial pushed UI and data-source outputs so replay is deterministic.
• Elm time-travel debugger: Freeze input and show an overlay while paused in the past.
• Elm time-travel debugger: Message-level redaction hook before export (Elm lacked one; eSpark had to build it).
• Streamlit: Ship agent skills inside the package and offer to install them on first error (Streamlit 1.59/1.62).
• Streamlit: run_every-style per-component refresh intervals as a first-class component property.
• Streamlit: AppTest-style headless harness: run, set widget values, read the element tree.
• driver.js: Step schema: {element, popover:{title, description, side, align}, data} plus advanceOnClick / waitForElement / skipMissingElement semantics.
• driver.js: Instance API names: drive, moveNext, movePrevious, moveTo, getState, highlight, refresh, destroy.
• driver.js: Hints as a separate lightweight layer (beacons) distinct from modal tours.
• marimo: Batch transactions: queue patches in a context, validate the whole batch (ids exist, bindings resolve, no cycles), apply atomically or reject naming the faulty nodes.
• marimo: Return per-node status after a batch (clean / errored / broken by upstream).
• marimo: Self-describing agent API: the skill tells the model to call help() at runtime so docs and implementation can't drift.
• marimo: Lesson from the 'MCP detour': fixed read-only tools underperform a general query surface; offer a flexible state query, not only canned getters.
• Motion Canvas: Named time events stored as data beside the tour: `waitUntil(name)` with timings editable without touching the script.
• Motion Canvas: Ripple semantics: moving one event shifts all later events unless held.
• Motion Canvas: Deterministic seek by re-running from the start (or a checkpoint) to frame N.
• asciinema + Charm VHS: Export scene history to asciicast v3 (with m markers for tour steps) so any asciinema player or site can play it.
• asciinema + Charm VHS: VHS-style tape vocabulary (Type, Sleep, Wait /regex/, Hide/Show, Screenshot) for scripted scene tours and golden tests.
• asciinema + Charm VHS: Player API shape: seek({marker: 'next'}), getCurrentTime, marker events, pauseOnMarkers.
• asciinema + Charm VHS: Live streaming of a scene session with adaptive buffering, as in asciinema stream.
• Perspective: Generate JSON schemas for the config/patch types and hand them to the agent as tool parameter schemas (as PR #3209 does).
• Perspective: Ship a docs bundle (BM25-searchable JSON) with the binary for agent retrieval.
• Perspective: Publish benchmarks per release as data files, and view them in the tool itself.
• Perspective: Partial config updates (ViewerConfigUpdate) vs full initial config as two distinct typed operations.
• Scrimba: Make 'take over' a fork of the recorded state at the playhead, and let 'resume' either discard the fork or diff it against the instructor's path.
• Scrimba: Audio/narration track keyed to the same timeline as UI events.
• Scrimba: Authoring is just 'record while you talk'; derive the tour from a session trace rather than hand-writing steps.