# herdr

> A terminal multiplexer rebuilt around long-running coding agents instead of shell sessions

- Category: AI Coding / Coding-Agent Harnesses & Runtimes
- Language: Rust
- Licence: Apache-2.0
- Repository: https://github.com/herdrdev/herdr
- Website: https://herdr.dev
- Canonical page: https://ai-tldr.dev/tools/herdr/

## In short

herdr is a terminal multiplexer rebuilt around long-running coding agents instead of shell sessions. It sits in the Coding-Agent Harnesses & Runtimes category of the AI Coding tools and is open-source, written in Rust and licensed Apache-2.0. To get started: install.

## Overview

herdr describes itself as "the runtime your coding agents live on". It is a terminal application, written in Rust and shipped as a single binary with no Electron runtime, that takes the multiplexer idea — panes, layouts, detach and reattach — and reshapes it for work where the thing occupying a pane is an agent rather than a person at a prompt.

The practical difference shows up in three places. Terminals keep running on a background server when the client disconnects, and layouts restore after a restart (the original processes themselves do not survive a reboot). Local work and remote SSH machines are consolidated into one interface, so a fleet of agents spread over several hosts is visible in a single window. And every pane carries a status — working, blocked or idle — which is the piece a normal multiplexer cannot give you, because "blocked waiting for approval" is not something a shell reports.

Agents are treated as first-class clients, not just processes being watched. They talk to herdr through a CLI and a socket API, which lets an agent open its own panes and coordinate with other agents running alongside it. It works with the mainstream coding agents — Claude Code, Codex, Cursor, OpenCode and Grok among them — and is driven either by tmux-style prefix-key bindings or with the mouse. A plugin system with a marketplace covers extensions.

## What it does

- Session persistence: terminals keep running on a background server after the client disconnects, and layouts restore on restart
- Local machines and remote SSH hosts consolidated into a single interface
- Per-pane agent status — working, blocked or idle — visible at a glance
- Agent-native CLI and socket API: agents create their own panes and coordinate with each other
- Works with Claude Code, Codex, Cursor, OpenCode, Grok and similar tools
- tmux-style prefix-key bindings plus mouse interaction
- Single Rust binary, no Electron; plugin system with a marketplace

## Getting started

herdr installs as one binary. The commands below come from the project README.

1. Install

   The install script covers macOS and Linux.

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

2. Or install with a package manager

   Homebrew and mise are both supported; a PowerShell install script is published for Windows, and binary releases are available for several architectures.

```bash
brew install herdr
# or
mise use -g herdr
```

3. Start it

   Running the binary with no arguments opens the multiplexer.

```bash
herdr
```

4. Detach and reattach

   Detaching leaves the server — and the agents in it — running. Re-running `herdr` reattaches to the same layout.

```bash
ctrl+b q   # detach
herdr      # reattach
```

5. Run your agents in panes

   Launch a coding agent inside a pane as you normally would; herdr tracks whether it is working, blocked or idle, and the agent can open further panes through the CLI and socket API.

```bash
claude
# or codex, opencode, cursor-agent, …
```

## When to use it

- Reach for it when several coding agents run at once and you need to see which ones are blocked on you
- Reach for it when agent work spans local and remote SSH machines and you want one window over all of them
- Reach for it when long-running agent sessions must survive a disconnect or a client restart
- Reach for it when you want agents to open and coordinate their own panes rather than driving a multiplexer by hand