`##pipe` and `##hop`: composing panes the way Unix composes processes
Unix's best idea was |. Rysh applies it one level up: panes — shells, agents, chats — composed into workflows instead of processes.
The best idea in the history of software is fifty years old and one character long: |.
Unix pipes won because they made a bet: small programs, each doing one thing, composed through a universal interface — text streams. Nobody had to design grep to know about sort. The composition was the architecture.
Then AI tooling arrived and forgot all of it. Today's agent products are monoliths: one big assistant, one context, one conversation that does everything badly the moment your workflow has more than one stage. We took the lesson of cat | grep | sort and rebuilt ed with a personality.
Rysh's bet is that the pipe was right — one level up. Not processes composed into pipelines. Panes.
Panes are the new processes
In rysh, a pane isn't a viewport; it's a conversation with an engine behind it — a shell, an autonomous agent, a chat, a live channel. Each pane is an actor on a NATS message bus, publishing its output as typed streams (shell output, AI output, chat, system — each on its own topic).
Stop and notice what that means: every pane already has stdin and stdout at the workspace level. Input flows in as messages; output flows out as streams anyone on the bus can subscribe to.
Which makes composition not a feature but an inevitability. If panes are processes, someone has to be |.
##pipe: wiring outputs to inputs
In rysh, the wiring is part of the built-in ## command language you type straight into a pane. ##pipe is the pipeline command: in a tab with pipeline mode on (##tab pipeline enable), ##pipe load <file> reads a pipeline definition — a YAML file in .rysh/pipelines/ — ##pipe run runs it, and ##pipe status shows where it stands.
The pane-to-pane primitive is ##pane listen, which subscribes one pane to another pane's output, and pipeline events — lines starting with ##> — let a pane emit structured signals that bypass the PTY entirely. A build pane can emit ##>event:sh:softdev:golang:unit_testing and a listening pane responds by running the test suite; emit an AI event and the listener's agent wakes up with that phase's prompt and any instructions you put in the event.
Chain that and you have an assembly line made of conversations:
[dev agent pane] → emits phase events →
[test pane] → runs go test on cue →
[review agent pane] → wakes on an AI event, drafts the fix
No orchestrator in the middle: each pane reacts to what it hears. Panes, composed.
##hop: because you're in the pipeline too
Unix pipes had no operator for the human — fair enough, sort doesn't need supervision. Agents do. In a governed workspace you are a stage in the pipeline: the one that approves, redirects, unblocks.
##hop is built for that reality. ##hop <pane> forks the current pane's conversation into another pane — its output and its agent's memory, tool calls included — so you can redirect a piece of work without retelling the story. Both panes then hold the same history and go their own ways; ##hop resume has the target's agent pick the task up where the source left off.
Events move signals between panes; ##hop moves a whole conversation — and you decide where it lands.
Why text streams still win
A subtle reason this works: what a rysh pane streams is, at heart, text — same as Unix. A shell's output, an agent's response, a chat message: text on a topic. Any pane can listen to another pane in the session.
Text is the only interface that survives — it's what your logs, your tools, and (not coincidentally) large language models are native in. The ##> event convention adds just enough structure — a prefix, a type tag — the same trick that made exit codes and stderr work without breaking the stream.
And composition doesn't route around the agent's approval flow: an agent woken by an AI event, or resuming after a hop, runs through the same prompt path as one you typed to; a shell-phase event runs its fixed command without asking. A pipeline you can watch, stage by stage — running on Claude with your key, on your machine.
The tell
Here's the challenge question for any agent tool you're evaluating: what's its composition story? If the answer is "the agent is very capable" — that's the monolith answer, the anti-Unix answer. Capability doesn't compose. Interfaces compose.
Rysh's answer is the oldest one in the book, dusted off: small conversational units, universal text streams, events to wire them, and an operator to carry a conversation between them.
McIlroy would recognize it. That's the point.
Composing agents into real workflows? That's exactly what our design partners are building with us — direct line to the founders: rysh.ai/design-partner.
More in this series: Pipeline events: building a software assembly line out of panes · ##pane listen: when one pane watches another work