On this page #
Once you run several coding agents at once, plain terminals and classic multiplexers stop being enough. Herdr fills the gap between tmux and agent apps.
Most AI coding setups still treat the terminal like a single shell with smarter autocomplete.
That model breaks the moment you run Claude Code, Codex, OpenCode, and Copilot CLI side by side.
You end up with four panes. Three SSH tabs. And no honest answer to a basic question:
Which agent is blocked? Which is still working? Which finished twenty minutes ago while you were staring at someone else’s logs?
tmux and Zellij keep sessions alive. Desktop agent apps give you nicer status views. Worktree managers like Conductor, Emdash, and Superset organize branches and reviews.
None of them fully cover the niche that shows up once agents become a herd: agent-aware multiplexing inside the terminal you already use.
Herdr frames itself as “to coding agents what tmux is to terminals.”
That line is the right diagnosis.
The missing layer is not another AI feature. It is a control room for long-running agent sessions.
This post maps the problem space, how Herdr attacks it, and where the alternatives still fit.
The Multi-Agent Terminal Reality #
A common day now looks like this:
- Claude Code refactoring a service in one pane
- Codex or OpenCode generating tests in another
- Copilot CLI exploring a remote repo over SSH
- A fourth pane watching
bun test
or build logs
Each tool is fine alone.
Together they create three failures that classic terminals do not solve.
Visibility fails first. You tab through panes and parse scrollback by eye.Persistence fails next. Close the laptop or drop SSH and you risk killing hours of agent work unless you already wired detach/reattach yourself.Orchestration fails last. You become the scheduler: start agents, watch logs, hand off tasks, restart the ones that stalled.
%%{init: {"layout": "dagre"}}%%
flowchart LR
You[You] --> A1[Claude Code]
You --> A2[Codex / OpenCode]
You --> A3[Copilot CLI]
You --> Logs[Tests / logs]
A1 -->|"blocked?"| You
A2 -->|"done?"| You
A3 -->|"still working?"| You
Why this hurts: the human stays in the hot path for state checks that software should own.
At two agents it is annoying. At five it is a second job.
What Classic Multiplexers Get Right and Miss #
tmux and Zellij already solve the hard infrastructure part:
- Persistent PTY sessions
- Panes, tabs, and layouts
- Detach/reattach locally and over SSH
They are excellent at keeping shells alive.
They are also agent-blind by design.
A Claude Code pane and a top
pane look the same: processes with output. Any notion of blocked vs working vs done has to be bolted on with scripts, plugins, or habit.
| Capability | tmux / Zellij | What multi-agent work still needs |
|---|---|---|
| Persistent PTYs | Yes | Same |
| Panes / tabs / SSH attach | Yes | Same |
| Know which pane is an agent | No | Yes |
| Blocked / working / done / idle | No | Yes |
| Wait on agent state from another agent | Script it yourself | First-class API |
That is the real gap.
Persistence without semantics leaves you with durable noise. You can reattach to a session and still spend five minutes figuring out which agent needs attention.
Desktop tools swing the other way.
cmux and Warp understand agents better, but they replace or wrap the terminal environment instead of sitting inside WezTerm, iTerm2, Ghostty, or Kitty.
Worktree orchestrators like Conductor, Emdash, and Superset operate one layer up: branches, diffs, review flows. Terminals are embedded details, not the primary runtime.
The key insight: multi-agent work needs both a real PTY runtime and agent semantics.
Most tools pick one.
How Herdr Attacks the Gap #
Herdr is a single Rust binary that runs inside your existing terminal.
It ships a TUI with workspaces, tabs, tiled panes, and themes. Underneath, the panes are real PTYs, not app-private shells.
Herdr’s session navigator: jump between agent panes without losing the herd view.
The architecture is client-server over a Unix socket:
- The server owns panes, workspaces, and session state - The client sends keystrokes and renders the UI - Detach the client and the agents keep running
- Reattach locally or over SSH, including a remote mode where the server lives on a Linux box and the client stays on your laptop
%%{init: {"layout": "dagre"}}%%
flowchart TB
Client[Herdr client / TUI] -->|"Unix socket"| Server[Herdr server]
Server --> P1[PTY: Claude Code]
Server --> P2[PTY: Codex]
Server --> P3[PTY: Copilot CLI]
Server --> State[Agent state: blocked / working / done / idle]
Out of the box it detects a dozen-plus coding agents from process names and output, then tracks state as blocked, working, done, or idle.
Workspace rollups surface the most urgent state so you can scan before you dive into a pane.
It also exposes a CLI and JSON socket API. Agents and harnesses can create panes, start other agents, read output, and wait on state changes.
That turns the multiplexer into something agents can drive, not only something humans rearrange.
Why this works: Herdr keeps the tmux persistence story and adds the missing labels: which process is an agent, what state it is in, and how another agent can act on that session.
Three Problems, Three Concrete Fixes #
Visibility: stop babysitting panes
Without agent state, attention is manual.
You open each pane. Scroll. Guess. Move on.
Herdr labels supported agents and rolls workspace state up to the highest-urgency condition. A blocked agent beats a working one. A working agent beats idle.
You attach when the sidebar says you should, not because you remembered to check.
That is a small product change with a large workflow effect: triage becomes a scan, not a tour.
Persistence: keep long jobs alive across disconnects
Agent work is often long-lived.
Refactors, test generation, and large codebase exploration can run for tens of minutes. If that work is tied to one terminal window or one SSH session, laptop sleep or a flaky link can wipe it.
Herdr’s server-owned PTYs give you the same detach/reattach contract tmux users already trust, including remote attach.
The agent keeps running while the UI comes and goes.
Orchestration: stop being the only scheduler
Most multi-agent setups still route coordination through a person.
You start the second agent after the first finishes. You copy context by hand. You watch for stalls.
With Herdr’s CLI and socket API, an orchestrator agent can create workspaces, split panes, launch other agents, read their output, and wait for state transitions.
The pattern the project leans into is blunt: “agents herding agents.”
herdr split --direction right
herdr send --pane 2 "claude 'generate tests for auth'"
herdr wait --state done --pane 2
herdr attach --pane 2
Why this matters: once agents can wait on each other through a shared session layer, the terminal stops being a pile of windows and starts looking like infrastructure.
Where Herdr Fits Against the Alternatives #
Use this table as a decision aid, not a ranking of “best tool.”
| Tool | Lives in your terminal | Persistent sessions / SSH | Agent state awareness | Agent-shaped API |
|---|---|---|---|---|
| Herdr | Yes | Yes (local + SSH) | Blocked / working / done / idle | CLI + socket (read / send / split / wait) |
| tmux | Yes | Yes | Process-level only | Shell scripting |
| Zellij | Yes | Yes | No built-in agent model | Plugins, not agent-first |
| cmux | No (Mac app) | Session / app restore | Some agent awareness | App-level APIs |
| Warp | No (full terminal app) | Partial restore | Native AI / attention features | Platform APIs |
| Solo | No (desktop app) | Managed processes | Process / workspace status | MCP / process APIs |
| Conductor / Emdash / Superset | No (workflow apps) | Embedded terminals / remote projects | Workspace / review status | Workflow APIs |
Short version by category:
tmux / Zellij: best generic session layer; add agent awareness yourselfcmux / Warp: stronger agent UX if you are willing to switch terminal homesSolo and similar desktop managers: fine for local GUI-centered stacksConductor / Emdash / Superset: better when the main problem is worktrees, diffs, and review flowHerdr: best when you want real PTYs, SSH persistence, agent state, and an API agents can drive without leaving the terminal
When to Choose What #
Choose Herdr if you:
- Run two or more coding agents in parallel on real workloads
- Need detach/reattach across laptop closes and SSH drops
- Want one scan of blocked / working / doneacross local and remote sessions - Plan to let agents create panes and wait on each other
Stay on tmux or Zellij if you:
- Mostly run one agent at a time
- Already have custom scripts that track status well enough
- Care more about generic shell multiplexing than agent semantics
Prefer cmux, Warp, or a desktop manager if you:
- Want a packaged app experience over a thin layer in your current terminal
- Work mainly on one machine and do not lean on SSH-heavy remote agents
Prefer Conductor, Emdash, or Superset if you:
- Care first about worktree isolation, branch assignment, and review orchestration
- Treat the live terminal as secondary to the workflow UI
Herdr is specialized.
If AI agents are a side tool, it is probably overkill. If they are becoming your day job, the specialization is the point.
Trade-offs Worth Knowing #
A few limits matter before you switch:
| Trade-off | What it means in practice |
|---|---|
| Windows preview / beta | Prefer macOS or Linux for daily use today |
| Extra concepts | Workspaces, navigate mode, agent states, and the socket API sit on top of ordinary multiplexer habits |
| AGPL-3.0-or-later | Some commercial teams will need the offered commercial license |
| Agent-centric design | Pays off when you run multiple agents long enough for state and persistence to matter |
Those are fair costs for a focused tool.
They are also the reason Herdr should not be sold as “tmux but prettier.”
The Bottom Line #
The multi-agent terminal problem is not “I need a smarter model.”
It is “I need visibility, persistence, and coordination for processes that think for minutes at a time.”
tmux and Zellij own persistence. Agent apps own pieces of the UX. Worktree managers own structured review.
Herdr sits in the remaining niche: an agent-aware multiplexer that stays inside your existing terminal, keeps real PTYs alive across disconnects, surfaces blocked / working / done / idle, and lets agents drive the session layer.
Treat agent sessions like infrastructure.
Monitor them. Persist them. Orchestrate them.
Once you do, a plain grid of panes stops looking like a complete answer.
Running multiple coding agents in terminals already? I’d love to hear what you use for visibility and handoffs. Reach out on LinkedIn.