Rysh vs Herdr and cmux: orchestrating other people's CLIs vs being the engine

Agent multiplexers are having a moment. But arranging other people's agents in panes and being the agent engine are different products.

There's a new genre of dev tool having a moment: the agent multiplexer. Run Claude Code in one pane, Codex CLI in another, a third agent refactoring tests in a corner, and you — the human — conducting the orchestra.

Herdr does this. cmux does this. And honestly? The instinct is right. One agent at a time was never going to be how serious teams work.

But there are two very different ways to build this product, and the difference decides what you can do a year from now.

Credit where it's due

Herdr is an agent multiplexer that runs inside your existing terminal. That's a genuinely clever design decision: you keep your shell, your keybindings, your muscle memory, and Herdr manages Claude Code, Codex, and Gemini CLI in panes around you. Zero relearning. Freemium, low friction.

cmux goes the other direction — an AI-native terminal/desktop app built for parallel agentic dev, with isolated workspaces per agent so parallel runs don't trample each other. Isolation-first is a real engineering position, and it's the right one for "run five attempts at the same bug."

If your goal is "arrange the coding agents I already use," both are good at exactly that.

The fork in the road

Here's the philosophical split.

Herdr and cmux orchestrate other people's CLIs. The agent is a black box — a subprocess whose stdout you watch. The multiplexer arranges boxes; the intelligence lives inside tools it doesn't control.

Rysh is the engine. A pane in rysh isn't a window onto some other agent's output — a pane is a conversation. The agentic loop (tool calls, approvals, memory, cancellation) runs inside rysh itself, on Claude, with your own API key. Same model you'd use anyway — we don't claim a better one. What's different is everything around the loop.

That difference sounds abstract until you list what it buys:

• Observability at the tool-call level. You don't watch an agent's log scroll by — you see each file edit as a coloured diff, each shell command, each approval prompt. It's your loop, so nothing is opaque.
• Approval gates as policy, not vibes. Destructive operations wait for a human. Read-only commands flow. You configure the line.
• Shared memory between agents. Panes share todo lists, context stores, and session history — agent B can read what agent A just did without you copy-pasting between windows.
• Pipelines between panes. One pane's output can trigger the next pane's work — a plan pane feeding a build pane feeding a test pane.
• Collaboration. ##share pane view or ##share pane control puts a teammate inside your session, watching or driving, live.
• Channels. The same skill file that defines a terminal agent can answer on Slack, email, and website chat today (WhatsApp and phone are on the roadmap, not live).
• Agents in git. An agent is a markdown skill file. Review it, diff it, ship it like code.

An orchestrator of CLIs can't easily grow these, because the interesting state lives inside processes it doesn't own.

Side by side

(Competitor rows sourced from our battlecards, June 2026 — check current docs before you decide.)

When to pick Herdr or cmux

Be honest with yourself:

• You love your terminal setup exactly as it is and won't give up your keybindings → Herdr. Running inside your existing terminal is its superpower.
• You mainly want isolated parallel runs of coding agents you already trust → cmux.
• You want the lightest possible conceptual change to how you work today → either one.

These are real answers, and for a solo dev arranging coding CLIs, they may be the right ones.

When to pick rysh

Pick rysh when the question stops being "how do I arrange my agents?" and becomes "how does my team — or my company — run agents?"

• You want to see and gate every tool call, not trust a subprocess.
• You want agents that share context instead of five amnesiacs in five boxes.
• You want to pair-debug with a colleague and an agent in one shared pane.
• You want the same agent definition working your terminal today and your support inbox tomorrow.

And here's the thing — it's not either/or. Rysh panes are real terminals. Several teams run Claude Code inside a rysh pane and get collaboration and governance layered on top. The orchestrators and rysh can coexist; only one of them is a platform.

Rysh is self-hostable — your infra, your Anthropic key, your data. Not open source, and we won't pretend otherwise.

We're early, and we're building this with design partners. If your team is juggling multiple agents and wants the engine, not another wrapper — come shape the roadmap: become a design partner →

More in this series: Rysh vs Claude Code · Rysh vs building it yourself