Every pane is a conversation: rethinking the terminal for the agent era
tmux treats a pane as glass in front of a shell. What happens if you treat every pane as a conversation instead? Everything changes.
For twenty years, a terminal pane has meant one thing: a rectangle of glass in front of a shell process. Keystrokes go in, bytes come out. The multiplexer's job — tmux, screen, Zellij — is to arrange the glass.
Here's the question that started rysh: what if a pane isn't glass? What if every pane is a conversation?
That sounds like a slogan. It's actually a data model, and once you commit to it, a surprising amount of the agent-era tooling problem just… falls out.
The mental model
In rysh, a pane is a participant you're talking to. What kind of participant is up to you:
- A shell. Type commands, get output. It's a real terminal — PTY-backed, vim and htop work, full interactive support.
- An AI. The same pane, flipped to prompt mode, is a conversation with an agent that can see your working directory and use 46+ built-in tools — files, git, search, web, test runners.
- An autonomous agent. A headless coworker you spawned from a markdown file, doing its own tool-use loop while you do something else.
- A live channel. A pane can be the terminal-side face of an agent that's answering your email or your website chat.
The flip between the first two is a single gesture — double-tap Escape:
$ go test ./... # shell mode: a normal terminal
[Esc Esc]
> why is TestPaneSnapshot flaky? # prompt mode: same pane, same cwd, same context
No new tab. No copy-pasting your error into a chat window that has never heard of your repo. The conversation happens where the work is, which turns out to matter more than any model upgrade.
Conversations can talk to each other
Glass can't collaborate. Conversations can — and this is where the model starts paying rent.
Panes in rysh are addressable and can observe each other. One pane can subscribe to another's output stream:
##pane listen builder
Now your test-runner pane watches your build pane. Push it further with pipeline events — a pane can emit structured events that trigger work in listening panes:
##>event:sh:softdev:golang:unit_testing
That line, emitted from a build pane, tells the listener to run the test suite for a Go project. You've built a tiny software assembly line out of panes — no YAML orchestrator, no CI round-trip, just conversations passing notes.
And because agents are named participants, you address them like colleagues:
@code-reviewer review the diff in pane 2
@ops-bot tail the staging logs and summarize errors
Under the hood this is honest architecture, not string parsing on top of a screen buffer: every pane is an actor with its own mailbox, and all coordination flows over an embedded NATS message bus. Output streams are real, separable topics — shell output, AI output, chat, and system messages are distinct streams per pane. That's why a pane can be watched, shared, or wired to a channel without the whole thing collapsing into soup.
Conversations can be shared
Here's my favorite consequence. If a pane is a conversation, then sharing a pane isn't screen-mirroring — it's inviting someone into the conversation.
##share pane view # → returns a share ID
A teammate on another machine:
##upstream subscribe <share-id> view
They're now watching your agent work, live, from their own terminal — every tool call, every diff, every approval prompt. view is read-only; control is a per-share decision when you want a second pair of hands. Pair-debugging where the pair is a human and an agent, and everyone can see what the agent is doing, is a genuinely different way to work.
(Honest note: treat a shared pane like a screen-share — shared streams aren't value-scrubbed today, so don't share panes where credentials get printed.)
Why glass can't get there
You could bolt an AI onto a classic multiplexer — plenty of tools do, and some are good. But the glass model caps how far that goes, because the primitive is wrong:
- Glass has one output stream: whatever the process printed. Conversations have separable streams you can route, watch, and govern independently.
- Glass has no identity: a pane is wherever your shell happens to be. Conversations have names, so
@agentaddressing and cross-pane coordination are natural. - Glass has no notion of actions, so there's nothing to approve. Conversations are made of tool calls — each one visible, the dangerous ones gated behind an explicit yes.
- Glass can only be mirrored. Conversations can be joined, with per-participant trust levels.
None of this requires abandoning the terminal you love. It's still panes, tabs, and keybindings; muscle memory survives. The change is underneath: the pane stopped being a window onto a process and became a participant in your work.
If you want to feel the difference, it's one binary:
brew install rysh-ai/rysh/rysh
rysh
Open a pane. Double-tap Escape. Say hello to it.
We're recruiting design partners. If your team lives in the terminal and wants agents in the workflow — not next to it — we want you steering the roadmap: rysh.ai/design-partner
Related: Meet rysh.ai · "So it's tmux with AI?"