Herdr: el multiplexor de terminales agent-native para correr múltiples agentes IA en paralelo

Qué es Herdr

Herdr es un multiplexor de terminales agent-native y open source que permite correr múltiples agentes de programación con IA en paralelo, cada uno en su propio terminal real (PTY), con persistencia total: cerrás la laptop, los agentes siguen trabajando. Reattach desde cualquier dispositivo, incluyendo tu teléfono via SSH.

No es un IDE, no es un wrapper, no es un orchestrator. Es el runtime sobre el que viven tus agentes. Un solo binario en Rust, sin Electron, que se ejecuta en cualquier terminal que ya uses.

Con más de 314,000 instalaciones, 24,300+ estrellas en GitHub y 19 agentes detectados automáticamente, Herdr se ha posicionado como la solución más pragmática para desarrolladores terminal-first que necesitan persistencia y paralelismo real.

Historia

Fecha	Hito
27 marzo 2026	Repositorio creado en GitHub (herdrdev/herdr)
2026	Desarrollo full-time, en el abierto. Sponsor directo funda desarrollo, estabilidad y el path a un agent runtime real
Agosto 2026	v0.8.0 — 314K+ installs, 24.3K stars, 150+ plugins comunitarios

Licencia: Apache 2.0. Lenguaje: Rust. Autor: ogulcancelik (GitHub sponsor). Modelo: free y open source, sin tiers pagos, sin telemetría, sin cuenta requerida.

Los 4 principios de diseño

1. Always running

Herdr no es una app que mantenés abierta. Es un server corriendo en background, y las terminales viven dentro de él. Cerrás la tapa o perdés red y los agentes siguen trabajando. Reiniciás la máquina y Herdr reconstruye el layout y resume las sesiones.

2. You never hunt for the stuck one

Herdr lee cada pane y marca cada agente como working, blocked o idle. Cuando uno se detiene y necesita una respuesta, te lo dice —no tenés que ir pane por pane buscando quién te está esperando.

3. Agent-native

El CLI y el socket API son la misma superficie que los agentes manejan. Los agentes pueden splitear panes, iniciarse entre sí, promperse entre sí, y esperar hasta que otro agente esté genuinamente bloqueado en lugar de disparar keystrokes y rezar.

4. Runs what you already run

Claude Code, Codex, Cursor, OpenCode, Grok, Copilot y el resto. Herdr no los wrappea ni los reemplaza —solo adueña sus terminales. Un binario, macOS y Linux, Windows en beta.

Agentes soportados (19 detectados out of the box)

Agente	State authority	Integration role
Pi	Lifecycle hooks (si instalado) / screen manifest	State y session
OMP	Lifecycle hooks	State y session
Claude Code	Screen manifest	Session
Codex	Screen manifest	Session
Cursor Agent CLI	Screen manifest	Session
OpenCode	Lifecycle plugin / screen manifest	State y session
Grok CLI	Screen manifest	Session
GitHub Copilot CLI	Screen manifest	Session
Devin CLI	Screen manifest	Session
Kimi Code CLI	Lifecycle hooks / screen manifest	State y session
Hermes Agent	Screen manifest	Session
Qoder CLI	Screen manifest	Session
Droid	Screen manifest	Session
Kilo Code CLI	Lifecycle plugin / screen manifest	State y session
MastraCode	Lifecycle hooks	State y session
Amp	Screen manifest	None
Antigravity CLI	Screen manifest	Session
Kiro CLI	Screen manifest	None
Maki	Screen manifest	None

Detected but less thoroughly tested: Gemini CLI y Cline. Los agentes no soportados igual corren como procesos de terminal normales —solo que pueden no tener rich state.

Cómo funciona la detección de estado

Para agentes con lifecycle hooks completos, la integración es autoritativa: reporta idle, working, blocked e identidad de sesión.

Para agentes sin lifecycle hooks, Herdr identifica el proceso foreground y lee el snapshot live del bottom-buffer. Evalúa manifests TOML contra ese snapshot para clasificar estado. Los manifests pueden también matchear terminal title y progress (OSC) sequences.

Herdr checkea herdr.dev por actualizaciones remotas de manifests y las aplica automáticamente sin requerir restart.

Instalación

macOS y Linux

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

Homebrew

brew install herdr

mise

mise use -g herdr

Windows (beta)

powershell -ExecutionPolicy Bypass -c "irm https://herdr.dev/install.ps1 | iex"

Binarios directos

Descargar desde GitHub releases.

Verificar instalación

herdr --version

Quick start: tu primer workspace

1. Iniciar Herdr

herdr

Si no hay workspaces, Herdr abre uno automáticamente. Un workspace es un contenedor a nivel proyecto para tabs, panes y agentes.

2. Usar el mouse

Herdr es mouse-native. Clickeá panes, tabs, workspaces y agentes para focusearlos. Arrastrá los borders para resize. Right-click para context menus (split panes, crear tabs). Drag-select para copiar texto. Double-click un token para copiarlo directo.

3. Correr un agente

claude

O codex, pi, opencode, o cualquier otro agente soportado. Herdr lo detecta automáticamente. El sidebar muestra si cada agente está working, blocked, done o idle —across todos los workspaces.

4. Control de teclado (opcional)

ctrl+b  — entrar en prefix mode

prefix+v     — split vertical
prefix+minus — split horizontal
prefix+c     — nuevo tab
prefix+n     — siguiente tab
prefix+p     — tab anterior
prefix+w     — navegar workspaces
prefix+q     — detach
prefix+?     — ver todos los bindings
prefix+[     — copy mode

El teclado es una capa opcional —el mouse cubre todo. Si preferís keyboard-only o querés que Herdr deje de capturar el mouse:

[ui]
mouse_capture = false

5. Detach y volver

# Detach
prefix+q  (o simplemente cerrá la terminal)

# Reattach
herdr

# Detener el server y todos los panes
herdr server stop

El server y todos los agentes siguen corriendo cuando te detachás. Reattach con herdr y volvés al mismo estado.

Conceptos核心

Workspace

Contenedor top-level de proyecto. Un workspace por repo, tarea o investigación. Posee tabs y panes. Su sidebar state roll-up desde los agentes dentro de él.

Tab

Un layout dentro de un workspace. Usá tabs para separar views: agents, logs, server, review. Addressable desde CLI y socket API.

Pane

Un terminal real. Herdr renderiza el output, envía input al proceso, y preserva el pane across detach. Panes se splitean right o down. Se pueden renombrar, leer desde CLI, enviar input y cerrar.

Agent

Un proceso que Herdr reconoce dentro de un pane. Estados: blocked, working, done, idle, unknown.

Session

Namespace persistente del server Herdr. El comando herdr attacha a la sesión default. Sesiones nombradas son runtime namespaces separados:

herdr session list
herdr session attach work
herdr session attach side-project

Client y Server

Por defecto, Herdr corre como background server + uno o más attached clients. El server posee panes y process state. El client es la terminal UI. Detach del client con ctrl+b q —el server y los agentes continúan.

Session state y restore

1. Live persistence (detach normal)

El server sigue corriendo. Panes, shells, agentes, servers, tests y procesos de comandos siguen vivos. Reattach con herdr. Es el path más fuerte porque los procesos originales nunca se detienen.

2. Snapshot restore (server restart)

Si el server se detiene y arranca de nuevo, Herdr restaura la forma guardada: workspaces, tabs, panes, cwd, layout y focus. Los procesos originales se pierden —vuelven como shells nuevos en sus directorios guardados.

3. Pane screen history replay

Restaura contenidos recientes del terminal después de un restart completo. Off por default (puede incluir secrets, tokens, prompts):

[experimental]
pane_history = true

4. Native agent session restore

Algunos agentes pueden resumir sus propias conversaciones. Herdr usa session references de integraciones oficiales para restartear agentes soportados después de un server restart. Activado por default.

Agentes soportados con resume nativo: Pi, OMP, Claude Code (claude --resume <id>), Codex (codex resume <id>), Cursor Agent (cursor-agent --resume <id>), Grok, Copilot, Devin, Droid, Kimi, Qoder, OpenCode, Kilo, Hermes, MastraCode.

# Desactivar si preferís
[session]
resume_agents_on_restore = false

# Verificar integraciones instaladas
herdr integration status

# Reinstalar integración outdated
herdr integration install <agent>

5. Live handoff (experimental)

Para updates y remote attach que necesitan reemplazar el server en vivo. Transfiere panes vivos al nuevo server —los procesos siguen corriendo across el reemplazo.

herdr update --handoff
herdr --remote workbox --handoff

Persistencia y acceso remoto

Detach y reattach

# Detach
ctrl+b q

# Reattach desde la misma máquina
herdr

# Reattach desde otra máquina via SSH
herdr --remote workbox
herdr --remote ssh://you@server:2222

Remote attach over SSH

En modo --remote, tu Herdr local es un thin client. Conecta over SSH, inicia o attacha al server remoto, y streamea la UI a tu terminal local. Como el client corre localmente, Herdr puede bridgear features del desktop local (como image clipboard paste) al session remoto.

Configurar SSH config para targets repetidos:

Host workbox
  HostName server.example.com
  User you
  Port 2222

Luego:

herdr --remote workbox

Usa tu autenticación OpenSSH normal. Si la key tiene passphrase en non-interactive shell, cargala en ssh-agent primero:

ssh-add
herdr --remote workbox

Remote desde teléfono

Podés reattach desde tu teléfono via SSH a tu server. La TUI de Herdr es responsive con mobile-friendly narrow-screen layout.

Socket API: control total desde scripts y agentes

El socket API es la misma superficie que el CLI. Lo que podés controlar:

• Crear, listar, focusear, renombrar y cerrar workspaces
• Crear, listar, focusear, renombrar y cerrar tabs
• Listar, inspeccionar, splitear, swap, focusear, resize, renombrar, leer, cerrar y enviar input a panes
• Listar, inspeccionar, leer, prompear, esperar, renombrar, focusear, iniciar y attachar agentes
• Reportar custom agent state desde hooks y plugins
• Subscribirse a eventos y esperar por output o state changes
• Instalar y desinstalar integraciones built-in
• Detener el server y recargar config

Ejemplos de CLI

# Crear workspace
herdr workspace create --cwd ~/project --label api

# Crear tab
herdr tab create --label logs

# Splitear pane y correr comando
herdr pane split w1:p1 --direction right
herdr pane run w1:p2 "npm test"

# Inspeccionar layout
herdr pane layout --current

# Esperar a que un agente termine
herdr agent wait w1:p1 --until done

# Leer output del pane
herdr pane read w1:p2 --source recent --lines 50

Schema del API

# Imprimir schema resumido
herdr api schema

# Schema completo en JSON
herdr api schema --json

# Guardar a archivo
herdr api schema --output herdr-api.schema.json

Agent automation: agentes que controlan agentes

Herdr expone 3 primitivos para automatización: workspace, tab, pane. Un agente puede usar el CLI/socket API para:

• Splitear panes y lanzar otros agentes
• Leer output de otro agente
• Esperar hasta que otro agente esté done o blocked
• Prompear a otro agente con un mensaje

Ejemplo: script que crea workspace, splitea y lanza 2 agentes

created=$(herdr workspace create --cwd ~/project --label api --no-focus)
pane_id=$(printf '%s\n' "$created" | jq -r '.result.root_pane.pane_id')
split=$(herdr pane split "$pane_id" --direction right --no-focus)
review_pane=$(printf '%s\n' "$split" | jq -r '.result.pane.pane_id')

# Lanzar Claude Code en el primer pane
herdr pane run "$pane_id" "claude"

# Lanzar Codex en el segundo pane para review
herdr pane run "$review_pane" "codex"

Agent skill

Herdr tiene un agent skill que podés pegar en tu agente para que aprenda los conceptos, setup, configuración y fixes comunes de Herdr —así sus respuestas son precisas en lugar de improvisadas.

Plugins

Los plugins son código ordinario que corre en tu máquina. Se instalan desde GitHub:

herdr plugin install owner/repo[/subdir]
herdr plugin install owner/repo --yes      # sin preview
herdr plugin install owner/repo --ref v1.0 # pin revision

Manifest (herdr-plugin.toml)

id = "example.layout"
name = "Layout"
version = "0.1.0"
min_herdr_version = "0.7.0"
description = "Apply project layouts"
platforms = ["linux", "macos", "windows"]

[[actions]]
id = "apply"
title = "Apply layout"
contexts = ["workspace"]
command = ["node", "dist/apply.js"]

[[events]]
on = "worktree.created"
command = ["herdr", "workspace", "list"]

[[panes]]
id = "board"
title = "Project board"
placement = "overlay"
command = ["herdr-board"]

[[link_handlers]]
id = "github-issue"
title = "Open GitHub issue"
pattern = "^https://github\\.com/[^/]+/[^/]+/(issues|pull)/[0-9]+$"
action = "apply"

Marketplace

Índice automático de repos públicos de GitHub taggeados con el topic herdr-plugin. Se refresca cada 30 minutos. Para listar tu plugin: agregá el topic herdr-plugin a tu repo público. Más de 150 plugins comunitarios disponibles.

Configuración

Archivo de config

# Linux y macOS
~/.config/herdr/config.toml

# Windows
%APPDATA%\herdr\config.toml

Ver config default completa

herdr --default-config

Recargar config en vivo

herdr server reload-config

Opciones principales

[terminal]
default_shell = "nu"        # shell para nuevos panes
shell_mode = "auto"          # login shells en macOS
new_cwd = "follow"           # heredar cwd del pane source

[ui]
mouse_capture = true         # false para keyboard-only

[experimental]
pane_history = false         # true para replay de historial

[session]
resume_agents_on_restore = true  # resume nativo de agentes

[remote]
manage_ssh_config = true     # false para ssh plano

[update]
manifest_check = true        # false para desactivar updates remotos

Precios

Plan	Precio	Incluye
Free / Open Source	$0	Todo. Sin tiers pagos, sin telemetría, sin cuenta requerida
Sponsor	Voluntario	Funda desarrollo, estabilidad y el path a un agent runtime real. Tiers en SPONSORS.md
Enterprise / Partnership	Custom	Contactar a [email protected]

Costo real: como herramienta self-hosted, vos bancás la infraestructura (cloud VM u on-prem hardware) para el server persistente. Pero el tool en sí es completamente gratis.

Herdr vs otras herramientas

Feature	Herdr	Conductor	tmux/Zellij
Tipo	Terminal multiplexer agent-native	Desktop app orquestador	Terminal multiplexer
Agent awareness	✅ 19 agentes detectados, state working/blocked/idle	✅ Claude Code, Codex, Cursor, OpenCode	❌ No agent-aware
Persistencia	Server background, sobrevive restart	Cloud microVMs (Vercel)	Server background
Remote access	SSH thin client, phone-friendly TUI	Cloud + mobile app (próximamente)	SSH attach
Agent-to-agent	✅ Socket API, agentes se controlan entre sí	❌	❌
Plataforma	macOS, Linux, Windows (beta)	Solo macOS	macOS, Linux
GUI	TUI (terminal)	Desktop app nativa	TUI
Plugins	150+ comunitarios via GitHub	Cursor Marketplace	Limitado
Precio	Free (open source)	$0-$60/user/mes	Free
Open source	✅ Apache 2.0	❌	✅

Casos de uso

1. Múltiples agentes en paralelo localmente

Claude Code en un pane implementando, Codex en otro revisando, OpenCode en un tercero corriendo tests. Todos visibles en el sidebar con su estado. Cerrás la laptop y todos siguen trabajando.

2. Remote dev box

Corrés Herdr en un server remoto. Attachás desde tu laptop con herdr --remote workbox. Los agentes viven en el server, persisten cuando te desconectás. Reattach desde tu teléfono en la calle.

3. Agent automation

Un agente orquesta a otros: crea workspaces, splitea panes, lanza agentes especializados, espera a que terminen y lee sus outputs. Todo via socket API o CLI.

4. CI/CD integration

Herdr corre en tu CI server. Un script crea un workspace, lanza un agente para fixear un issue, espera a que termine, lee el output y abre un PR. Todo automatizado.

5. Pair programming asíncrono

Tu teammate y vos attachan al mismo Herdr server desde máquinas distintas. Ambos ven los mismos panes y agentes trabajando. Uno puede detach y el otro seguir monitoreando.

Limitaciones

• Windows en beta — algunas features (remote attach, mouse capture) pueden no funcionar completamente
• Pane history replay off por default — puede incluir secrets en el output guardado
• Live handoff experimental — puede interrumpir requests in-flight, subscriptions y pane-to-pane messages
• No es un IDE — es un multiplexer de terminales. No tiene file tree, editor visual, o diff viewer integrado
• Self-hosted — vos bancás la infraestructura del server persistente
• Detección de blocked es estricta para screen-manifest agents —solo marca blocked cuando matchea UI visible de approval/question/permission

Conclusión

Herdr llena un gap estrecho pero real: desarrolladores que ya usan múltiples CLI agents y necesitan persistencia across máquinas o remote servers. No compite con Conductor (que es un desktop app con GUI) ni con Cursor (que es un IDE). Compite con tmux y Zellij —pero con agent awareness que ninguno de los dos tiene.

Para devs terminal-first que viven en SSH y manejan múltiples agentes, Herdr es la solución más pragmática. Es free, open source, un solo binario en Rust, sin telemetría, sin cuenta. El socket API que permite que agentes se controlen entre sí es algo que ninguna otra herramienta ofrece —es el path más claro hacia orquestación de agentes real desde la terminal.

Si ya usas tmux para mantener sesiones persistentes y empezaste a integrar agentes IA en tu workflow, Herdr es el upgrade natural. Migrás en minutos: mismos prefix keys, mismo detach/reattach, pero con estado de agentes, resume nativo y automatización via API.