`##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
That's ##pipe — rysh's composition operator, part of the built-in ## command language you type straight into a pane. Where | connects a process's stdout to the next process's stdin, ##pipe connects panes: one pane's output stream feeding another pane's input.
The primitive it builds on is already visible elsewhere in rysh: ##pane listen subscribes one pane to another's shared 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 accumulated context from the source pane.
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] → reads failures, drafts the fix
No orchestrator YAML. No workflow engine. 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 movement built for that reality — getting you (and your attention) across the workspace to where the action is, without the arrow-key archaeology of a deep tab/lane/stack layout.
Composition without navigation is a dashboard you can't reach. ##pipe moves data; ##hop moves you.
Why text streams still win
A subtle reason this works: rysh pane streams are, at heart, text — same as Unix. We deliberately did not invent a proprietary inter-agent protocol with schemas and handshakes. A shell's output, an agent's response, a chat message: text on a topic. Any pane can consume any pane.
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 because composition runs over the same bus as everything else, it inherits the governance for free: piped input into an agent pane triggers the same approval gates as typed input; every hop and every forwarded line is visible in the panes it touches. A pipeline you can watch, stage by stage — running on Claude with your key, self-hostable on your machines.
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, an operator to wire them and an operator to move you 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