Primary question: Does your multi-agent setup need persistent server-backed sessions with built-in blocked/working/done state, or is plain tmux enough?
RepoDaily adoption score
RepoDaily rates this as 92/100 (strong) for adoption: evidence, installation path, production risk, differentiation, license clarity, and AI/agent fit are scored from the article sources and adoption notes.
6 source(s) across 4 source category/categories, plus a RepoDaily-specific evidence module when available.
7 workflow step(s), 6 next-action step(s), and 3 command/install signal(s) were detected.
Trending momentum is +706 stars, with maintenance/release/issue signals counted when present.
Risk is marked medium, with 6 security note(s) and 5 explicit skip condition(s).
3 opportunity lens item(s), 5 alternative(s), and 4 type-specific section(s) support differentiation.
License source or license wording is present.
6 AI/agent-related signal(s) were detected in the article text and metadata.
Project overview
herdr is a terminal workspace manager that treats AI coding agents as first-class citizens. Written in Rust and shipping as a single ~10MB binary, it provides each agent its own real pseudo-terminal — not a redrawn imitation — so full-screen TUI applications render correctly. A background server keeps panes and agent processes alive when you detach, meaning you can close your laptop and reattach from another terminal or over SSH from your phone.
The project positions itself explicitly against two categories. Against tmux, it argues that tmux was built before agents existed and has no native concept of which pane is blocked, working, done, or idle. Against GUI agent managers such as Conductor, cmux, and Emdash, it argues that those are often Mac-only apps that wrap the terminal inside a GUI rather than running inside the terminal you already use. herdr tries to combine the persistence and SSH-accessibility of tmux with the agent-state awareness of GUI managers.
The current release is 0.7.1 (2026-06-24), and the changelog shows active work on agent lifecycle hooks for OMP, OpenCode, Pi, and Devin; worktree integration for Git operations; configurable UI pane borders and gaps; and refined paste handling for Windows Terminal. The project is dual-licensed under AGPL-3.0-or-later for open-source use and a separate commercial license for organizations that cannot comply with AGPL terms.
With 706 stars over the trending period and a prior #1 GitHub Trending day on Jun 30, 2026, herdr is resonating with developers who have hit the ceiling of managing multiple agent sessions across tmux tabs or separate terminal windows. The question for evaluators is whether agent-state awareness and socket-driven orchestration justify adopting a young, solo-maintained tool over battle-tested multiplexers.
Why it is trending now
- Fills a gap that tmux and Zellij do not address: each agent pane rolls up to a live status (blocked, working, done, idle) with zero hooks required.
- Single ~10MB Rust binary with no runtime dependencies runs on Linux and macOS (Windows beta), over SSH, inside the terminal developers already use.
- Background server keeps all agents alive across detach and reattach — close the laptop, reconnect from another machine or phone.
- Socket API and CLI let agents and external scripts drive pane creation, worktree operations, and session orchestration programmatically.
- Direct comparison table in the README against tmux, Zellij, cmux, Warp, and Conductor makes the positioning immediately legible to newcomers.
Problem it solves
- tmux has no native concept of agent state: every pane looks the same, and wiring per-harness hooks for blocked/working/done is manual and fragile.
- GUI agent managers (Conductor, cmux, Emdash) often redraw the terminal inside a wrapper, which breaks full-screen TUI rendering and locks you to a specific desktop app.
- When you close a terminal window or laptop lid, agent processes die — losing context, session state, and in-progress work.
- Managing five or more agents across separate terminal windows or tmux tabs provides no shared view of which agents are blocked and need human intervention.
- Remote agent fleets running on servers have no unified management surface accessible from a phone or SSH client.
How it works
- Install via `curl -fsSL https://herdr.dev/install.sh | sh` on Linux/macOS, or the PowerShell preview script on Windows.
- Launch herdr inside your existing terminal. It starts a background server process that owns all panes and agent sessions.
- Create workspaces organized by repo or folder, then split panes and tabs with mouse-native click, drag, and split interactions.
- Each agent you launch gets its own real PTY via the vendored portable-pty library, so full-screen TUIs render as the agent intended.
- The sidebar automatically classifies each agent as blocked, working, done, or idle — no hooks or configuration required for basic detection.
- Detach at any time. The background server keeps every pane and agent alive. Reattach from another terminal or over SSH.
- Use the local socket API and CLI to script pane creation, trigger worktree operations, or let agents orchestrate each other through plugins written in any language.
Commands, Config Keys, and Installation Surface
- Install (Linux/macOS): `curl -fsSL https://herdr.dev/install.sh | sh`
- Windows preview beta: `powershell -ExecutionPolicy Bypass -c "irm https://herdr.dev/install.ps1 | iex"`
- Manual update: `herdr update` continues to work even when background checks are disabled.
- Version 0.7.1 config keys: `[update].version_check`, `[update].manifest_check`, `ui.pane_borders`, `ui.pane_gaps`, `ui.agent_panel_sort = "priority"`
- Theme config: `[theme].auto_switch` with `dark_name` and `light_name` for automatic light/dark UI switching.
- Remote key config: `keys.remote_image_paste = "ctrl+v"` (default for `herdr --remote`).
- Environment hint: `HERDR_AGENT=<agent>` for Linux foreground-process identification when `/proc` cannot expose the real command behind wrappers like VMs, Bubblewrap, or `fence`.
- Worktree creation now checks out an existing local branch when the requested branch already exists instead of failing (#729).
Architecture and Dependency Stack
- Single Rust binary, ~10MB, edition 2021, built via `build.rs`.
- TUI rendering: ratatui 0.30 with the `unstable-rendered-line-info` feature.
- Terminal I/O: crossterm 0.29 for cross-platform terminal control.
- Async runtime: tokio with `rt-multi-thread`, `macros`, `sync`, and `time` features.
- Local IPC: interprocess 2.4.2 for the socket API that agents and scripts drive.
- PTY management: portable-pty 0.9.0, vendored at `vendor/portable-pty` via a crates.io patch.
- Windows support: windows-sys 0.61.2 with features spanning Console, Threading, Pipes, and Shell subsystems.
- Schema generation: schemars 1.2.1, with the API schema shipped at `docs/next/api/herdr-api.schema.json`.
Agent Integrations and Socket API
- Official hook integrations confirmed in CHANGELOG 0.7.1: OMP, OpenCode, Pi, and Devin.
- Topic tags reference Claude Code and Codex as supported agent ecosystems.
- Hook lifecycle and session reports are scoped to the intended root agent process, reducing stale or cross-process session adoption after restarts (#614, #712, #719, #765).
- OMP now reports a native session reference, enabling `omp --resume=<session>` after exiting and rerunning `omp` in the same pane (#614).
- Socket API documentation lives at https://herdr.dev/docs/socket-api/, with a JSON schema included in the binary's package includes.
- Plugins can be written in any language per the README, and the socket API is the primary programmatic surface.
- Worktree operations started through the socket API defer long-running Git work until the app runtime can drive it, keeping clients responsive (#657, #662, #686).
Maintenance and Project Health
herdr is a solo project maintained by ogulcancelik, as stated explicitly in CONTRIBUTING.md. The maintainer notes that many design and technical decisions are deliberate and that the guide exists to keep herdr manageable as a solo project. New contributors face an approval gate: before opening a first PR, they must get maintainer approval on an accepted issue and be added to `.github/APPROVED_CONTRIBUTORS`.
The CHANGELOG for 0.7.1 shows substantial breadth: 3 added features, 5 changed behaviors, and 10+ fixed issues spanning Windows paste handling, CJK branch-name truncation, host terminal color queries, hook lifecycle recovery, and Kitty file-transfer support. Issue references go up to #765, indicating an active tracker. However, the solo-maintainer model means bus-factor risk is real — organizations depending on herdr for production agent fleets should consider the commercial license path for a support relationship.
Who should pay attention?
Good fit if
- You regularly run three or more coding agents across different repos and lose track of which is blocked.
- You SSH into a remote server to run long-lived agent sessions and need them to survive disconnects.
- You use tmux today but have tried (and failed) to wire per-harness hooks for agent state detection.
- You want a scriptable surface (socket API + CLI) to programmatically launch, monitor, and orchestrate agents.
- You run full-screen TUI agents that break inside GUI wrapper applications.
Skip for now if
- You run a single agent at a time and your current terminal is sufficient.
- Your organization cannot comply with AGPL-3.0 and you are not prepared to negotiate a commercial license.
- You are a Windows-primary user who needs production stability (Windows is still in preview beta).
- You need a GUI-first experience with mouse-driven dashboards rather than a terminal-native tool.
- Your agents do not output TUI content and a simpler pane manager like tmux meets your needs.
Risks and cautions
AGPL-3.0-or-later license creates obligations for organizations running modified versions on network-accessible servers; solo maintainer concentrates bus-factor risk; Windows support remains in beta.
- AGPL-3.0-or-later requires source-code disclosure for modified versions running on publicly accessible servers — organizations must evaluate compliance or purchase a commercial license (contact hey@herdr.dev).
- The project is maintained by a single developer (ogulcancelik) with an explicit approval gate for new contributors, limiting how quickly external contributions can scale.
- Windows is listed as preview beta, with 0.7.1 fixing multiple Windows-specific paste and focus issues — not yet production-grade on that platform.
- At version 0.7.1, the API surface and agent-detection manifest format may still evolve before a 1.0 stability commitment.
- Background version checks and remote agent-detection manifest checks phone home by default, though both can be disabled independently via config.
- Background version checks and remote agent-detection manifest checks can be disabled independently via `[update].version_check` and `[update].manifest_check` (#677).
- No account or telemetry is required — the README explicitly states 'no account, no telemetry.'
- Socket API is local (interprocess crate), not exposed to the network by default.
- Single self-contained binary with no runtime dependencies reduces the software supply-chain surface.
- Agent note in CONTRIBUTING.md instructs AI agents not to use GitHub CLI/API to submit issues on behalf of users — issues must be human-submitted.
- Portable-pty is vendored locally (`vendor/portable-pty`) rather than pulled from crates.io, giving the maintainer direct control over the PTY code path.
Alternatives to compare
| Approach | When to use | Trade-off |
|---|---|---|
tmux | You need a mature, battle-tested terminal multiplexer with persistent sessions, panes, and SSH access — but you do not need built-in agent-state awareness. | Free, ISC/BSD-licensed |
Zellij | You want a modern Rust-based terminal multiplexer with plugin support but without agent-specific state tracking. | Free, MIT-licensed |
Conductor | You prefer a GUI desktop application that manages agent state with visual dashboards and are on macOS. | Commercial product |
cmux | You want a GUI agent manager with visual state indicators and can work within its desktop-app model. | Varies — check vendor |
Warp | You want an AI-enhanced terminal experience with built-in command suggestions rather than a multi-agent session manager. | Free tier with paid features |
What this trend reveals
Socket API as a fleet-orchestration primitive
The local socket API at https://herdr.dev/docs/socket-api/ exposes pane creation, worktree operations, and agent lifecycle hooks. Teams building internal agent-orchestration platforms can drive herdr as the execution layer from a separate controller service, using the JSON schema at docs/next/api/herdr-api.schema.json for type-safe integration.
Read the socket API docs, point a script at the local socket, and verify that worktree creation (#729) and pane lifecycle events fire correctly through the API path.
Remote agent fleet management over SSH
Because herdr runs as a single binary on a server with a background process that survives detach, a developer can manage a fleet of agents on a remote machine from a phone. The `HERDR_AGENT` env var and `herdr --remote` key configuration are specifically designed for this scenario.
Install herdr on a remote Linux server via SSH, launch three agents, detach, and reattach from a different SSH session to confirm all panes and agent states persist.
Plugin ecosystem in any language
The README states plugins can be written in any language and driven through the socket API. There is currently no published plugin registry or SDK, which means early plugin authors can define the integration patterns for specific agent harnesses (Claude Code hooks, Codex session management, custom internal tools).
Write a minimal plugin in Python or Node that connects to the socket API, creates a pane, and reports its state — then check whether the plugin lifecycle events described in #657 fire as documented.
RepoDaily verdict
herdr solves a real pain point that tmux does not address — knowing which agent is blocked without manually inspecting each pane. The Rust binary is fast, the background server model is sound, and the socket API opens legitimate orchestration paths. The main constraints are AGPL-3.0 licensing for organizational use, solo-maintainer bus-factor risk, and Windows being in beta. For developers already running multiple coding agents on Linux or macOS who need SSH-accessible persistence, herdr is worth a 30-minute evaluation.