Herdr Review: Open-Source Agent Multiplexer for AI Coding

If you’re running three, five, maybe ten AI coding agents at the same time — Claude Code in one terminal, Codex in another, Copilot CLI in a third — you already know the pain. You have terminal sessions scattered everywhere and zero visibility into which agent needs your attention right now.

Herdr is a free, open-source agent multiplexer built in Rust that solves exactly this problem. It runs inside your existing terminal (iTerm2, Kitty, Alacritty, WezTerm, Ghostty — whatever you already use) and adds a sidebar that shows real-time agent state: blocked, working, done, idle. Think of it as tmux that actually understands AI coding agents.

The project is about 105 days old, has nearly 15,000 GitHub stars, hit #1 on GitHub Trending on June 30, 2026, and is built by a single full-time developer. That kind of traction usually means the tool solves a real problem.

What is Herdr?

Herdr positions itself as “one terminal for the whole herd.” At its core, it’s a terminal-native agent runtime and multiplexer that combines tmux-style session persistence with first-class awareness of AI coding agents.

It runs inside your existing terminal — it doesn’t replace it. You launch Herdr and get a mouse-friendly TUI where you can split panes, manage named sessions, and see which agents are active. The key difference from tmux: Herdr detects AI agents running in its panes and displays their state in a sidebar.

Here’s what that looks like in practice:

The architecture is client-server: a background session server manages PTY sessions (they survive laptop sleep, WiFi drops, SSH disconnects), and a thin client renders the TUI. Communication happens over a local Unix socket, or through an SSH tunnel for remote access.

Herdr is a single Rust binary — about 10–11 MB. No Electron, no accounts, no telemetry, no cloud dependency.

If you’ve looked at tools like FreeBuff or Zcode as AI coding environments, Herdr sits in a different category. Those are agent wrappers. Herdr is the terminal layer underneath — it manages the panes and sessions where agents run, and adds orchestration capabilities on top.

Why terminal-native agent multiplexing matters

The multi-agent workflow is no longer niche. In 2026, a typical developer might run Claude Code for architecture decisions, Codex for implementation, Copilot CLI for quick edits, and Gemini CLI for research — all in parallel. Each agent runs in its own terminal session, and you’re constantly context-switching between them.

The pain points are real and consistent across the community:

1. No visibility. You have 10+ agent sessions open and no idea which one is blocked waiting for your input, which is still working, and which finished an hour ago.
2. GUI wrappers are limiting. Most are Mac-only, Electron-based, or replace your terminal entirely. If you work on a Linux VPS or want to access your agents from your phone over SSH, you’re out of luck.
3. Remote access is an afterthought. Running agents on a headless server and managing them from your laptop shouldn’t require a full desktop environment.
4. Agents can’t orchestrate. In tmux, agents are isolated in their panes. There’s no way for one agent to spin up another, wait for results, or read output from a sibling pane.

Terminal-native matters for the self-hosting and VPS crowd because it means zero overhead. No Electron, no desktop dependency, no GPU requirements. You can run Herdr on a $5 Hetzner VPS and access it from your phone via SSH. If you’re interested in SSH port forwarding workflows, Herdr’s remote attach mode fits right in.

Herdr key features

Agent state tracking

This is the feature that makes Herdr more than just another terminal multiplexer.

Herdr detects agents using process-name matching plus terminal output heuristics. For most of the 14+ supported agents, detection is zero-config — launch the agent in a pane and Herdr picks it up automatically. It tracks four semantic states:

• Working — the agent is actively generating or processing
• Blocked — the agent is waiting for user input (a prompt, permission, etc.)
• Done — the agent finished its task
• Idle — a pane exists but no agent activity detected

For richer state reporting, you can install agent-specific integrations:

herdr integration install claude
herdr integration install codex
herdr integration install copilot

Integrations add hooks that report state more accurately than heuristics alone. For example, the Claude Code integration uses its SessionStart hook to report initialization, task progress, and completion states.

Persistent sessions and detach/reattach

Like tmux, Herdr runs a background session server that manages PTY sessions. Your agent sessions survive laptop sleep, WiFi drops, and SSH disconnects.

Named sessions make it easy to organize:

# Start or attach to a named session
herdr session attach work
herdr session attach side-project

# List active sessions
herdr session list

# Kill a session
herdr session kill side-project

Detach from a session (default prefix is Ctrl+B, then D), and reattach later with herdr session attach. Your agents keep running in the background the whole time.

Mouse-native TUI

If you’ve bounced off tmux because everything requires keyboard shortcuts, Herdr might change your mind. The TUI is fully mouse-aware:

• Click to select panes
• Drag pane borders to resize
• Right-click for context menus (split, close, rename)
• Touch support works over SSH — you can manage agents from your phone

The layout adapts to narrow terminal widths, so it works reasonably well even on small screens.

Remote SSH attach

This is where Herdr gets interesting for the VPS and self-hosting crowd. You can run Herdr on a remote server and attach to it from your local machine:

# SSH into the server and launch Herdr directly
ssh user@your-server
herdr

# Stream the remote TUI to your local terminal
herdr --remote ssh://user@your-server:2222

# With SSH config aliases
herdr --remote ssh://myserver

Host myserver
    HostName your-server
    User user
    Port 2222
    IdentityFile ~/.ssh/id_ed25519

The Moshi iOS terminal app has native Herdr support, which means you can manage your agent fleet from an iPhone or iPad over SSH.

How to install Herdr

Herdr is a single Rust binary with no runtime dependencies. Installation takes under a minute.

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

brew install herdr

nix profile install github:ogulcancelik/herdr

git clone https://github.com/ogulcancelik/herdr
cd herdr
cargo build --release

# PowerShell one-liner
iwr -useb https://herdr.dev/install.ps1 | iex

The binary is about 10–11 MB. After installation, verify it works:

herdr --version

Getting started with Herdr

Your first workspace

Launch Herdr by running:

herdr

You’ll see the TUI with a single pane. Key keybindings use a prefix model (default Ctrl+B), similar to tmux:

• Ctrl+B, then V — split vertically
• Ctrl+B, then - — split horizontally
• Ctrl+B, then arrow keys — navigate between panes
• Ctrl+B, then D — detach from session
• Ctrl+B, then X — close current pane

You can also do all of this with the mouse — click to select panes, drag borders to resize, right-click for the context menu.

Create a named session from the start:

herdr session attach my-workspace

Running multiple coding agents

Here’s where Herdr earns its keep. Open multiple panes and launch different agents in each:

# Pane 1: Claude Code for architecture
claude

# Pane 2: Codex for implementation
codex

# Pane 3: Copilot CLI for quick edits
copilot

The agent state sidebar on the right shows what each agent is doing in real time. When Claude Code is waiting for your input, its state flips to “blocked” with an indicator. When Codex is generating code, it shows “working.” You can glance at the sidebar and immediately know which pane needs your attention.

This is especially useful when you’re running a lead agent plus helper agents. The lead handles the main task while helpers run in parallel on subtasks — and you see all their states at once.

Installing agent integrations

For better state detection, install integrations for your agents:

herdr integration install claude
herdr integration install codex
herdr integration install copilot
herdr integration install gemini
herdr integration install grok

Integrations add hooks that report richer state information. Without integrations, Herdr uses process-name matching and terminal output heuristics — which work, but integrations give you more granular status (e.g., “generating code” vs “waiting for tool approval” vs “idle”).

Herdr socket API and agent orchestration

This is the feature that differentiates Herdr from every other terminal multiplexer. Agents can drive the terminal programmatically through a socket API.

Instead of just running inside panes, agents can:

• Create new panes — spin up helper agents on demand
• Run commands — execute shell commands in any pane
• Read output — capture stdout from other panes
• Wait on state — block until another agent reaches a specific state (done, idle, etc.)
• Split and attach — manage workspace layout programmatically

Here’s what orchestration looks like from the CLI:

# Create a new pane in the current workspace
herdr pane split --vertical

# Run a command in the active pane
herdr pane run "claude --prompt 'Fix the authentication bug'"

# Read the last 50 lines of output from pane 2
herdr pane read --pane 2 --lines 50

# Wait until pane 2's agent reaches "done" state
herdr wait --pane 2 --state done

# Create a named workspace for a specific task
herdr workspace create feature-branch

Practical use cases:

• Lead agent + helpers: One agent runs the main task, spawns helper agents for subtasks (linting, testing, documentation), and waits for them to finish.
• Automated test-and-fix loops: An agent runs tests, reads the output, fixes failures, and repeats — all through the socket API.
• Multi-repo workflows: Different agents work on different repositories in parallel, coordinated by a lead agent.

Herdr vs tmux vs Zellij

This is the comparison most people want to see. Here’s an honest breakdown:

When tmux is still the better choice: If you have a deeply customized .tmux.conf, rely on specific tmux plugins, or have 18 years of muscle memory around tmux keybindings, switching to Herdr has real costs. tmux is also the safer bet for production server management where stability matters more than features.

When Herdr wins: If you run multiple AI coding agents and want real-time visibility into what they’re doing, there’s no alternative. The agent state sidebar alone justifies the switch for multi-agent workflows. The socket API is a bonus that opens up orchestration patterns tmux simply can’t support.

Herdr plugins and community ecosystem

The plugin ecosystem is young but growing fast. There are already 83+ public repositories tagged “herdr” on GitHub.

Notable community plugins:

• herdr-plus — Adds Quick Actions (predefined command templates) and a Projects view for organizing workspaces
• herdr-file-viewer — A git-aware file viewer TUI (64 GitHub stars). Browse files, see diffs, and navigate your project without leaving Herdr
• herdr-reviewr — Code review sidebar (44 stars). Review pull requests directly in Herdr
• ccgram — Telegram bridge for Herdr (202 stars). Get notifications on Telegram when agents finish, block, or error
• vim-herdr-navigation — Vim/Neovim integration for pane navigation
• pi-bellwether — Package manager integration for Herdr management

Third-party tools are also emerging:

• Moshi — An iOS terminal app with native Herdr support. Manage your agent panes from an iPhone.
• Agentchute — Intra-agent communication layer that works with Herdr’s socket API

The ecosystem is roughly where tmux was in its first year. The plugin count is growing fast (from zero to 83 repos in ~105 days), and the quality of the top plugins is already decent. Expect this to mature quickly given the project’s growth trajectory.

Who should (and shouldn’t) use Herdr

Licensing and pricing

Herdr is licensed under AGPL-3.0-or-later — free for personal and commercial use. You can download, run, and modify it without paying anything.

Key licensing details:

• Zero telemetry — no phone-home, no analytics, no usage tracking
• No account required — download and run. No cloud dependency.
• No vendor lock-in — it’s a standard Rust binary. If you stop using it, your terminal and agents are unaffected.

For context on the broader open-source AI ecosystem, see our guide to open source LLMs for coding — running open-source models with an open-source terminal multiplexer is about as vendor-neutral as you can get.

Risks and things to know

Honest caveats:

1. Young project. Pre-1.0, ~105 days old. APIs and features may change. If you build workflows around the socket API, expect some adaptation as the project evolves.
2. Solo developer. Bus factor is 1. Ogulcan Celik is full-time on this, but there’s no team backing it. The community (nearly 15,000 stars) helps, but core development depends on one person.
3. Missing tmux features. No battery/CPU status bar widgets. No session resurrection equivalent to tmux-resurrect. No tmuxinator-style project templates (yet).
4. Performance on large setups. Some users on Hacker News reported text rendering delay with many panes open. Your mileage may vary with 10+ panes.
5. No built-in sandboxing. Agents run with your user permissions. If an agent does something destructive, Herdr won’t stop it.
6. No public commercial pricing. Organizations need to email for a quote — no self-serve option.
7. Keybinding learning curve. The prefix-based model is familiar to tmux users, but the specific bindings differ. Expect a few days of adjustment.

The rapid community growth (15,000+ stars, 83+ repos, active Discord) mitigates some of these risks. Tools that solve real problems tend to attract contributors and survive.

Verdict

Herdr is the first terminal multiplexer that actually understands AI coding agents. If you’re running multiple agents and losing track of which ones need you, the agent state sidebar alone is worth the switch.

It’s not a tmux replacement yet — not for power users with deep customization needs. tmux has 18 years of ecosystem maturity, and Herdr has 105 days. But for the specific use case of multi-agent terminal workflows, nothing else comes close.

The socket API is novel. No other terminal multiplexer lets agents coordinate programmatically — creating panes, reading output, waiting on state. This opens up orchestration workflows that aren’t possible with tmux or Zellij.

The honest recommendation: try it for your next multi-agent session. Run Herdr for a day with three or four agents, watch the state sidebar, and see if it changes how you work. If it doesn’t, tmux is still there. If it does, you’ll probably stick with it.

If you’re also exploring affordable AI models to pair with Herdr, or looking at AI coding tools and assistants more broadly, we have guides for both.

FAQ