Frames · 11 entries

The frame layer: window managers and agent multiplexers

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, and the verdict for fictty

The open debates are terminal frame versus desktop frame, whether frames will eat the content layer, and whether a frame can be a business at all. In terminal frames the content layer is still unclaimed. herdr's plugin v1 is terminal-UI-only. TUIOS's ask-human (fixed-answer questions) and dock components (commands bound to cells) are the first small steps, and zellij's host-drawn components still come from compiled WASM. For fictty, the scope line holds: no frame lets an agent push a UI value, patch it by id, bind live data to it and read back its state. But exact text read-back is no longer unique, because herdr pane.read, zellij subscribe, tmux capture-pane and tuios screenshot --text all provide it. fictty's distinct claims are semantic state read-back, data that skips the model, and behaviour at frame rate. fictty should integrate rather than compete: emit OSC 7501 and OSC 9/777, report status to herdr, and ship recipes for herdr plugins, TUIOS popups, tmux 3.8 modal panes and zellij floating panes. It should build no frame features.

The entries

terminal · frame · project

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.

complementevidence: strong terminal · frame · project

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.

complementevidence: strong native · frame · product

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.

complementevidence: strong terminal · frame · project

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).

complementevidence: strong terminal · frame · project

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.

complementevidence: strong native · frame · product

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.

inspireevidence: mixed native · frame · product

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.

inspireevidence: thin browser · frame · project

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.

inspireevidence: strong native · frame · product

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.

watchevidence: mixed native · frame · product

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.

watchevidence: mixed terminal · frame · project

Claude 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.

watchevidence: strong

The overview

The frame layer: window managers and agent multiplexers

Research as of 10 October 2026. Dossiers: TUIOS, herdr, zellij, tmux, Wave, the Codex app, Warp, and four we added: cmux, Superset, Claude Squad, Vibe Kanban. Every entity on the original list exists; none was dropped.

What is really being solved

Not UI. Attention. A person now runs five to fifty long-lived agents, on several machines, in worktrees, for hours. The frame layer answers four questions for them:

Which one needs me? Per-pane status (working, blocked, done, errored) and one place to see every blocked agent: TUIOS’s Inbox, herdr’s pane marks, cmux’s blue rings, Superset’s chimes, Warp’s notifications.
Will it still be there? Sessions that survive a dropped SSH connection or a reboot (herdr, TUIOS, tmux, zellij, Wave’s durable sessions).
Can agents coordinate without me? Socket APIs and CLIs so agents spawn panes, prompt each other and wait on each other (herdr, TUIOS, cmux, zellij 0.44, tmux).
Where do I review? Diffs, previews and PRs beside the agent, with the person’s feedback routed back (Superset, Vibe Kanban, the Codex app, cmux’s browser).

The paths people are taking

Path A: the terminal multiplexer, rebuilt for agents. herdr (Rust, 43k stars in six months), TUIOS (Go, 5k), with tmux and zellij as the incumbents and Claude Squad as the first-wave ancestor. They run anywhere a terminal does, cross SSH, and own the PTYs. Their content is whatever program runs in a pane. They are converging fast on the same surface: a JSON socket API, pane.read-style text read-back of any pane, event subscriptions, status reporting, popups and overlays for plugins.

Path B: the desktop agent workspace. The Codex app (now inside the ChatGPT desktop app), Warp, cmux, Superset, Wave, Vibe Kanban. They are windows, not terminals, and they are steadily absorbing the content layer: in-app browsers with comments, Sites, MCP Apps, inline visualizations (Codex); Pages with comments and a watching agent (Superset); browser panes with accessibility-tree scripting (cmux); AI-written Go widgets (Wave’s Tsunami, planned). In every case the content is HTML or code, checked by screenshot or DOM.

The emerging standard: status reporting. Three mechanisms compete: OSC 7501 (the Program Status Protocol from Superlogical’s Rex terminal, revision 0.3 of 7 October 2026, implemented by TUIOS and parsed by libghostty-vt), herdr’s pane report-agent CLI with sequence numbers, and the older notification sequences OSC 9/99/777 (cmux, Warp). Any program in a pane can now say “I’m waiting for you” and appear in the frame’s inbox.

The open debate

Terminal frame or desktop frame? herdr’s growth says the terminal frame is thriving; the Codex-into-ChatGPT merger says the labs are betting on windows. Both are growing. Remote, long-running agents favour the terminal; review and rich previews favour the window.
Does the frame eat the content? In GUI frames, yes, already, via HTML. In terminal frames, not yet: herdr’s plugin v1 is “terminal UI only” and says native plugin UI isn’t part of v1; TUIOS’s ask-human (a question with fixed answers) and dock components (commands bound to cells) are the first small steps. Zellij is the only one with host-drawn components (table, ribbon, nested list, text) described by plugins, but they are written from compiled WASM code.
Is the frame a business? Vibe Kanban’s company shut down in April 2026 despite 28k stars; Warp open-sourced its client and leans on cloud orchestration; cmux and Superset sell cloud and mobile. The frame is crowded and hard to charge for.

What this means for fictty

The scope line holds. No frame lets an agent push a UI value, patch it by id, bind live data to it, and read back its state. fictty is still content-for-a-pane, and every terminal frame is a host for it.
But one claim is weaker than we wrote. Exact text read-back is no longer unique: herdr pane.read, zellij subscribe/dump-screen, tmux capture-pane and tuios screenshot --text all give agents the text of any pane. fictty’s distinct claims are semantic state read-back (get --state: which row is selected, what was typed, by node id), data that skips the model, and behaviour at frame rate. The blog post should say this.
Integrate, don’t compete. Concretely: emit OSC 7501 and OSC 9/777 when a screen waits; call herdr pane report-agent when HERDR_ENV=1; ship a herdr plugin manifest and recipes for tuios popup, tmux 3.8 modal panes (new-pane -O -W) and zellij floating panes. Build no frame features (sessions, detach, remote, multi-agent status).
The window of opportunity is real and finite. If herdr adds a declarative plugin UI, or TUIOS grows ask-human into forms and tables, the content layer gets claimed from above by tools with the distribution. fictty’s best defence is to be the thing they’d embed: small, data-first, embeddable, spoken over a socket.
Teaching. Frames are about supervising agents, not understanding things; their content is still mostly text the agent printed. The exceptions point at teaching: zellij’s read-only sharing tokens (“for teaching, demonstrations”), Codex’s inline visualizations, Superset’s commentable Pages. None of them gives a learner a live, explorable screen built for the moment in the place the agent already runs. That remains open ground.

Also seen, not dossiered

Conductor (closed macOS app for parallel Claude Code/Codex), Sculptor (Imbue, MIT, 238 stars), Crystal (now Nimbalyst, MIT, 3.1k stars, last release February 2026), Coder’s agentapi (an HTTP API over agent TUIs, MIT, 1.5k stars), Dagger’s container-use (Apache-2.0, 4k stars; isolation, not a frame), the Rex terminal (Superlogical; author of OSC 7501; we couldn’t confirm licence or platforms), and the terminals themselves (Ghostty 62k, kitty 35k, WezTerm 29k), whose features (libghostty-vt, kitty graphics, kitty sessions) increasingly decide what frames can do.

Sources

See each dossier. Star counts and release dates were read from the GitHub API on 10 October 2026.