Herdr: A Terminal Built for Agents That Outlive Your Laptop Lid

Herdr is a terminal multiplexer written in Rust and built around AI coding agents. It runs as a background server that owns your terminals rather than the other way round, tracks whether each pane is working, blocked or idle, and gives agents a socket API they can drive themselves.

The name is the pitch. You are not running a terminal any more. You are herding a flock.

Key takeaways

• Sessions survive a closed lid, a dropped VPN and a machine restart, because the server outlives the terminal you were looking at.
• Every pane carries a state: working, blocked, or idle. That one addition is what makes ten concurrent agents legible.
• Agents call Herdr through a CLI and socket API — they can spawn panes, prompt each other, and wait until another agent is genuinely blocked.
• Around twenty-one agents are detected automatically. It observes them; it does not wrap them.
• One Rust binary. No Electron, no runtime, cross-platform including Windows.
• Pre-1.0, with a big open issue queue for its age. Great for internal work; pilot before you depend on it.

What breaks when you run five agents?

Two things, and neither is the agent's fault.

The first is fragility. You start a long refactor, close the laptop to go to a meeting, and come back to a dead SSH session and forty minutes of lost work. Terminals were designed on the assumption that a human is sitting in front of them. An agent working for an hour is a different workload wearing the same interface.

The second is worse, because it scales with how much value you are getting. Five agents in five tmux panes: one finished twenty minutes ago, one is mid-build, one is stuck on a y/n prompt and has been for the entire time, and two are working. From the outside all five look identical — a pane with text in it.

So you cycle through panes checking on them. You have become a polling loop. The parallelism you bought is spent on supervision, which is precisely the work you were trying to delegate.

tmux cannot help, and it is not a criticism — it has no concept of "this pane is waiting for a decision" because in 1990 no pane ever was.

How does Herdr fix it?

1. Invert the ownership. Herdr is a background server; the terminals live inside it. Your window is a view onto the server, not the thing hosting the work. Detaching, crashing or rebooting your client is survivable.
2. Give every pane a state. Working, blocked, idle. Herdr detects the agent running in each pane and surfaces which ones have stopped and need an answer. You look once and know where to go.
3. Let agents drive it. The CLI and socket API are not just for you. An agent can spawn a pane, hand work to another agent, and wait until that agent is genuinely blocked rather than polling on a timer.
4. Detect rather than wrap. Herdr recognises the agents it hosts without replacing or proxying them, so you are not stuck waiting for it to support the next one.

That third point is the interesting one. "Wait until agent B is actually blocked" is a synchronisation primitive. With it, one agent can supervise several others without any orchestration framework — just a terminal server that knows what its panes are doing.

What does it look like to use?

Installation is one line:

curl -fsSL https://herdr.dev/install.sh | sh

On Windows, a PowerShell equivalent; Homebrew, mise and Nix are all supported too. Then the basic loop:

herdr                    # Start server
ctrl+b q                 # Detach session
herdr                    # Reattach to session

Familiar if you have used tmux — the prefix key is the same by default. The difference is what you see when you attach: not four identical rectangles, but four panes with states, one of which is flagged as waiting for you.

It is also mouse-first, which purists will resent and everyone else will quietly enjoy. Click a pane to focus, drag a border to resize, right-click to split.

Herdr vs tmux vs zellij

If you run one agent at a time, tmux is fine and always will be. The case for Herdr starts at three concurrent agents and gets stronger from there.

Alternatives worth knowing

• tmux — decades of stability, on every machine you will ever SSH into, and never going to surprise you. For persistence alone it remains the right answer.
• zellij — a modern multiplexer with a friendly default UI and a real plugin system. Nicer to learn than tmux, and stable, but with no agent awareness.
• A CI runner — genuinely worth considering. If the long job is deterministic, a pipeline gives you persistence, logs and notifications without a new tool on every developer's machine.
• Your agent's own background mode — several agents now run tasks in the background and notify on completion. If that covers your case, you do not need a multiplexer at all.

Limitations to plan around

• Pre-1.0. Behaviour and configuration can shift between releases. Read the notes before upgrading a machine that is running something you care about.
• The open issue count is high relative to the project's age. That is what fast growth looks like, but it is a data point.
• Windows has documented rough edges. Supported, but not yet the smoothest platform.
• Live upgrade without killing sessions is experimental and opt-in. Treat a server upgrade as a restart unless you have tested otherwise.
• Persistent agents need guardrails. An agent that survives your laptop closing is an agent that can keep making changes while you are not watching. Scope its permissions accordingly.

Conclusion

Herdr is a good example of a tool that only makes sense because the workload changed. Nobody needed a blocked-pane indicator when panes contained humans. Now that they contain processes which stop and wait for permission, the gap is obvious in hindsight.

If you are running one agent, keep using tmux. If you are running five and spending your day checking on them, this is the tool that gives that time back.

Scaling AI-assisted delivery across a team?

DI Solutions sets up agent workflows that hold up under real project pressure — sensible permissions, reproducible environments, and review gates that catch what the agent got wrong. Work with our engineering team to get there without the false starts.

Reference links

• Herdr on GitHub
• herdr.dev — install and documentation
• tmux wiki — the incumbent