If you have been running coding agents for a while, you have probably hit the same wall: the agent is mid-task, you close the laptop or your SSH connection drops, and the work dies with the window. The agent lives and dies with the UI that happened to be showing it.
Herdr takes a different angle. It is not another agent dashboard — it is a runtime. A background server owns real terminals on your machine; the agents live inside those; and every UI is just a client that attaches to them. Close the client and the herd keeps working.
Runtime, not an app
The distinction matters more than it sounds. Most tools in this space are apps — a window you open to manage agents, and the thing the work depends on. Quit the app and the agents stop.
Herdr inverts that:
- The server owns the terminals. It holds real PTYs open, like tmux does, but with agent awareness layered on top.
- Everything else is a client. The TUI, the CLI, plain SSH — each one attaches, detaches, or even crashes without the agents noticing.
- The UI is disposable. Your agents are not.
The project describes it as “the runtime coding agents run on,” and that framing holds up once you separate where the work runs from what you look at.
Install
Linux and macOS:
curl -fsSL https://herdr.dev/install.sh | sh
herdr
Windows PowerShell:
powershell -ExecutionPolicy Bypass -c "irm https://herdr.dev/install.ps1 | iex"
herdr
Homebrew, mise, and Nix installs are also supported. Direct installs use the stable
channel and update with herdr update; package-manager installs update the normal
way. Check what you have with herdr --version.
The concept model
Herdr’s vocabulary is worth learning before you start clicking, roughly in this order:
| Concept | What it is |
|---|---|
| Session | A persistent background server namespace. herdr attaches to the default one. |
| Workspace | A project-level container, one per repo or task. Owns tabs and panes. |
| Tab | A layout inside a workspace — for example agents, logs, server. |
| Pane | A real terminal, splittable right or down. Survives client detach. |
| Agent | A process Herdr recognizes inside a pane, with a state. |
Agent states are the useful part: working, blocked, done, idle, and
unknown. The sidebar rolls these up per workspace, so you can glance across all
your projects and see which agent is working, which one is blocked waiting on you,
and which has finished.
There are three input modes: terminal mode sends keys to the focused pane,
prefix mode (ctrl+b, then one action key) sends a single command to Herdr,
and navigate mode is a persistent navigation surface.
First run
Herdr is deliberately mouse-first, so you do not need to memorize shortcuts to
start. cd into a project and run:
herdr
That launches or attaches to the default background session and creates a workspace
automatically. Then start your agent in the pane — claude, codex, or anything
else on the supported list — and Herdr detects it. Where an integration exists,
installing it adds lifecycle state, native session restore, or both:
herdr integration install claude
From there, the basics are all in the UI: click panes and tabs to focus, drag
borders to resize, right-click for menus, drag-select to copy. When you do want the
keyboard, prefix+? shows every active binding, and splitting is
prefix+v (right) or prefix+minus (down).
Detach, reattach, and go remote
To detach, use prefix+q or just close the terminal window. Everything keeps
running. Reattach later with herdr — panes preserve scrollback and state, and
supported agents can even resume their native session.
For machines you do not sit in front of, SSH in and run herdr there like you would
tmux, or attach as a thin local client:
herdr --remote <host>
Either way, the session you left is still there.
Scripting and plugins
Herdr is not just interactive. A CLI and a local socket API let scripts and agents drive it programmatically — read output, wait on another agent, split panes, attach to a specific agent. Agents can even drive themselves through the same socket.
There is also a plugin system: local executable workflow plugins with manifest actions and event hooks, shareable from GitHub. (Community plugins are numerous, so the ecosystem is already non-trivial.)
A few commands that help when something looks off:
herdr status # summarize the runtime
herdr agent list # what Herdr sees
herdr agent explain <t> # why a pane was classified that way
herdr --default-config # print the full default config
herdr server reload-config
herdr server stop # actually stop everything
Configuration lives in ~/.config/herdr/config.toml on Linux and macOS and
%APPDATA%\herdr\config.toml on Windows. It works fine without one.
How it fits alongside other tools
It is tempting to slot Herdr next to tmux, terminal apps like Warp, or agent manager apps. The comparison page makes a clean argument for why it does not quite fit any of those boxes:
- tmux and zellij persist terminals, not agents. Herdr keeps the whole detachment model but adds the part multiplexers never had: knowing which pane is an agent, whether it is blocked, and how to wait on it instead of polling.
- Terminal apps replace your terminal and move the work into their renderer. Herdr runs inside whatever terminal and SSH access you already have.
- Manager apps are clients without a runtime. They are useful for worktrees and review flows, and Herdr pairs fine with that flow — but they are not where agents live.
The row that sorts the field is simple: what happens to the agents when the thing you are looking at goes away. With an app, they stop. With Herdr, they keep going.
Worth a look
Herdr is open source under Apache 2.0, and the install is a one-liner. If you run more than one agent across more than one project — or you have ever lost an agent’s work to a closed lid — the runtime model is a genuinely different answer to the problem. Point your agent at the docs and let it walk you through setup:
Help me understand and set up Herdr. Read https://herdr.dev/agent-guide.md first, then walk me through it step by step.
I have been running agents from plain terminals for a while, and the “server owns the terminals, every UI is a client” split is the part that finally makes detach-and-reattach feel like it was designed for agents rather than retrofitted onto them.