---
title: "Herdr Review: Open-Source-Agent-Multiplexer für AI-Coding"
description: "Herdr Review: ein kostenloser Open-Source-Agent-Multiplexer, der AI-Coding-Agents nebeneinander in einem Terminal laufen lässt. Features, Setup und der Vergleich mit tmux."
date: 2026-07-10
categories: ["tools"]
tags: ["herdr","agent-multiplexer","ai-coding"]
---

Wenn du drei, fünf, vielleicht zehn AI-Coding-Agents gleichzeitig laufen lässt — Claude Code in einem Terminal, [Codex](/codex-app-any-model/) in einem anderen, Copilot CLI in einem dritten — kennst du den Schmerz schon. Du hast Terminal-Sessions überall verstreut und null Überblick darüber, welcher Agent gerade deine Aufmerksamkeit braucht.

Herdr ist ein kostenloser, in Rust gebauter Open-Source-Agent-Multiplexer, der exakt dieses Problem löst. Er läuft in deinem bestehenden Terminal (iTerm2, Kitty, Alacritty, WezTerm, Ghostty — was immer du schon nutzt) und fügt eine Sidebar hinzu, die den Agent-State in Echtzeit zeigt: blocked, working, done, idle. Stell es dir als tmux vor, das AI-Coding-Agents tatsächlich versteht.

Das Projekt ist ungefähr 105 Tage alt, hat fast 15.000 GitHub-Sterne, stand am 30. Juni 2026 auf Platz 1 der GitHub-Trending-Liste und wird von einem einzigen Fulltime-Entwickler gebaut. Diese Art von Traktion bedeutet meist, dass das Tool ein echtes Problem löst.

**Was du lernen wirst**

Dieses Review behandelt, was Herdr ist, wie es sich zu tmux und Zellij verhält, wie man es installiert und konfiguriert und ob es sein Versprechen von terminal-nativem Agent-Multiplexing einlöst. Enthalten ist ein Hands-on-Video-Walkthrough, wie ich es im Alltag nutze. Wenn du [AI-Coding-Tools und -Assistants](/ai-coding-tools/) erkundest, hilft dir das zu entscheiden, ob Herdr in deinen Workflow passt.

---

## Was ist Herdr?

Video: [Herdr: The Terminal Multiplexer That Actually Works](https://www.youtube.com/embed/NKppWN1atkQ)

Herdr positioniert sich als „ein Terminal für die ganze Herde". Im Kern ist es eine terminal-native Agent-Runtime und ein Multiplexer, der tmux-artige Session-Persistenz mit First-Class-Bewusstsein für AI-Coding-Agents kombiniert.

Es läuft in deinem bestehenden Terminal — es ersetzt es nicht. Du startest Herdr und bekommst eine mausfreundliche TUI, in der du Panes splitten, benannte Sessions verwalten und sehen kannst, welche Agents aktiv sind. Der zentrale Unterschied zu tmux: Herdr erkennt AI-Agents, die in seinen Panes laufen, und zeigt ihren Zustand in einer Sidebar an.

So sieht das in der Praxis aus:

![Herdr-Architekturübersicht mit Client-Server-Modell, Session-Server, PTY-Panes, Agent-State-Sidebar und Socket-API](@assets/images/26/07/herdr-architecture.webp)

Die Architektur ist Client-Server: Ein Hintergrund-Session-Server verwaltet PTY-Sessions (sie überleben Laptop-Sleep, WLAN-Abbrüche, SSH-Disconnects), und ein Thin Client rendert die TUI. Die Kommunikation läuft über einen lokalen Unix-Socket oder durch einen SSH-Tunnel für Remote-Zugriff.

Herdr ist eine einzelne Rust-Binary — ungefähr 10–11 MB. Kein Electron, keine Accounts, keine Telemetrie, keine Cloud-Abhängigkeit.

**Was Herdr dir gibt:**
- tmux-artige persistente Sessions mit Detach/Reattach
- Echtzeit-Agent-State-Sidebar (blocked/working/done/idle)
- Maus-native TUI mit Klicken, Ziehen, Splitten und Rechtsklick-Menüs
- CLI und Socket-API für agent-gesteuerte Orchestrierung
- Remote-SSH-Attach für Headless-Server
- Plugin-System mit Community-Marketplace
- 14+ AI-Coding-Agents out of the box unterstützt
- Null Telemetrie, kein Account nötig

Wenn du Tools wie [FreeBuff](/de/freebuff-kostenloser-ki-coding-agent/) oder [Zcode](/zcode-ai-review/) als AI-Coding-Umgebungen angesehen hast: Herdr sitzt in einer anderen Kategorie. Das sind Agent-Wrapper. Herdr ist die Terminal-Schicht darunter — es verwaltet die Panes und Sessions, in denen Agents laufen, und legt Orchestrierungsfähigkeiten obendrauf.

---

## Warum terminal-natives Agent-Multiplexing zählt

Der Multi-Agent-Workflow ist längst keine Nische mehr. 2026 fährt ein typischer Entwickler Claude Code für Architekturentscheidungen, Codex für die Implementierung, Copilot CLI für schnelle Edits und Gemini CLI für Recherche — alles parallel. Jeder Agent läuft in seiner eigenen Terminal-Session, und du springst ständig zwischen ihnen hin und her.

Die Pain Points sind real und in der Community konsistent:

1. **Kein Überblick.** Du hast 10+ Agent-Sessions offen und keine Ahnung, welche blockiert auf deinen Input wartet, welche noch arbeitet und welche vor einer Stunde fertig wurde.
2. **GUI-Wrapper sind limitierend.** Die meisten sind Mac-only, Electron-basiert oder ersetzen dein Terminal komplett. Wenn du auf einem Linux-VPS arbeitest oder von deinem Handy per SSH auf deine Agents zugreifen willst, hast du Pech.
3. **Remote-Zugriff ist ein nachträglicher Gedanke.** Agents auf einem Headless-Server laufen zu lassen und sie vom Laptop zu verwalten sollte keine volle Desktop-Umgebung erfordern.
4. **Agents können nicht orchestrieren.** In tmux sind Agents in ihren Panes isoliert. Ein Agent kann keinen anderen hochfahren, auf Ergebnisse warten oder Output aus einem Nachbar-Pane lesen.

Terminal-nativ ist für die Self-Hosting- und VPS-Crowd wichtig, weil es null Overhead bedeutet. Kein Electron, keine Desktop-Abhängigkeit, keine GPU-Anforderungen. Du kannst Herdr auf einem 5-$-Hetzner-VPS laufen lassen und von deinem Handy per SSH darauf zugreifen. Wenn dich [SSH-Port-Forwarding](/ssh-tunneling-linux/)-Workflows interessieren, passt Herdrs Remote-Attach-Modus genau da rein.

---

## Herdrs wichtigste Features

### Agent-State-Tracking

Das ist das Feature, das Herdr zu mehr macht als nur ein weiterer Terminal-Multiplexer.

Herdr erkennt Agents über Prozessnamen-Matching plus Terminal-Output-Heuristiken. Bei den meisten der 14+ unterstützten Agents ist die Erkennung Zero-Config — starte den Agent in einem Pane und Herdr greift ihn automatisch auf. Es trackt vier semantische Zustände:

- **Working** — der Agent generiert oder verarbeitet aktiv
- **Blocked** — der Agent wartet auf User-Input (einen Prompt, eine Permission etc.)
- **Done** — der Agent hat seine Aufgabe abgeschlossen
- **Idle** — ein Pane existiert, aber keine Agent-Aktivität erkannt

Für reichhaltigeres State-Reporting kannst du agent-spezifische Integrationen installieren:

```bash
herdr integration install claude
herdr integration install codex
herdr integration install copilot
```

Integrationen fügen Hooks hinzu, die den Zustand genauer melden als Heuristiken allein. Die Claude-Code-Integration zum Beispiel nutzt deren `SessionStart`-Hook, um Initialisierung, Task-Fortschritt und Abschluss-Zustände zu melden.

**14+ Agents unterstützt**

Herdr unterstützt Claude Code, Codex, Copilot CLI, Cursor Agent, Pi, Droid, Amp, OpenCode, Grok CLI, Gemini CLI, Antigravity CLI, Kimi Code CLI, [Hermes Agent](/hermes-agent-setup-guide/), QoderCLI, Kiro CLI und mehr. Wenn dein Agent nicht gelistet ist, funktioniert die generische Prozess-Erkennung meist trotzdem — sie meldet nur nicht so viel Detail.

### Persistente Sessions und Detach/Reattach

Wie tmux fährt Herdr einen Hintergrund-Session-Server, der PTY-Sessions verwaltet. Deine Agent-Sessions überleben Laptop-Sleep, WLAN-Abbrüche und SSH-Disconnects.

Benannte Sessions machen das Organisieren einfach:

```bash
# 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
```

Detache von einer Session (Default-Prefix ist `Ctrl+B`, dann `D`) und reattache später mit `herdr session attach`. Deine Agents laufen die ganze Zeit im Hintergrund weiter.

### Maus-native TUI

Wenn du an tmux abgeprallt bist, weil alles Tastatur-Shortcuts erfordert, könnte Herdr deine Meinung ändern. Die TUI ist komplett mausfähig:

- Klicken, um Panes auszuwählen
- Pane-Ränder ziehen, um die Größe zu ändern
- Rechtsklick für Kontextmenüs (splitten, schließen, umbenennen)
- Touch-Support funktioniert über SSH — du kannst Agents von deinem Handy aus verwalten

Das Layout passt sich schmalen Terminal-Breiten an, funktioniert also auch auf kleinen Screens einigermaßen gut.

### Remote-SSH-Attach

Hier wird Herdr für die VPS- und Self-Hosting-Crowd interessant. Du kannst Herdr auf einem Remote-Server laufen lassen und von deiner lokalen Maschine attachen:

![Herdr-Remote-SSH-Attach-Workflow: Laptop verbindet sich durch einen SSH-Tunnel mit einem VPS mit Session-Server](@assets/images/26/07/remote-ssh-workflow.webp)

### Direktes SSH

```bash
# SSH into the server and launch Herdr directly
ssh user@your-server
herdr
```
Funktioniert, rendert aber die volle TUI über SSH — okay auf guten Verbindungen, zäh auf langsamen.

### Thin Client (--remote)

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

# With SSH config aliases
herdr --remote ssh://myserver
```
Der Thin-Client-Modus streamt nur die Rendering-Daten, was auf langsamen Verbindungen reaktiver ist als rohes SSH.

### SSH-Config-Aliase

Füge deiner `~/.ssh/config` hinzu:
```
Host myserver
    HostName your-server
    User user
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
```
Dann nutze: `herdr --remote ssh://myserver`

Die Moshi-iOS-Terminal-App hat nativen Herdr-Support, heißt: Du kannst deine Agent-Flotte von einem iPhone oder iPad über SSH verwalten.

---

## Herdr installieren

Herdr ist eine einzelne Rust-Binary ohne Runtime-Dependencies. Die Installation dauert unter einer Minute.

### curl (Linux/macOS)

```bash
curl -fsSL https://herdr.dev/install.sh | sh
```
Lädt die neueste Binary herunter und legt sie in `/usr/local/bin/` ab.

### Homebrew

```bash
brew install herdr
```
Verfügbar in Homebrew Core (v0.7.3 zum Zeitpunkt des Schreibens). Installiert auf Intel- wie Apple-Silicon-Macs.

### Nix

```bash
nix profile install github:ogulcancelik/herdr
```
Funktioniert mit Nix Flakes. Schau ins Repo für das aktuelle flake.nix, wenn du pinnen willst.

### Cargo (aus Source)

```bash
git clone https://github.com/ogulcancelik/herdr
cd herdr
cargo build --release
```
Braucht die Rust-Toolchain. Der Build erzeugt eine einzelne Binary unter `target/release/herdr`.

### Windows (Beta)

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

**Windows-Beta**

Der Windows-Support ist funktional, aber noch in Beta. Linux und macOS sind die primären Plattformen. Auf Windows rechne mit gelegentlichen rauen Kanten.

Die Binary ist ungefähr 10–11 MB groß. Verifiziere nach der Installation, dass sie funktioniert:

```bash
herdr --version
```

---

## Erste Schritte mit Herdr

**Bevor du startest**

Du brauchst einen Terminal-Emulator (iTerm2, Kitty, Alacritty, WezTerm, Ghostty oder jedes moderne Terminal), Herdr installiert und mindestens einen AI-Coding-Agent installiert (Claude Code, Codex, Copilot CLI etc.).

### Dein erster Workspace

Starte Herdr mit:

```bash
herdr
```

Du siehst die TUI mit einem einzelnen Pane. Die zentralen Keybindings nutzen ein Prefix-Modell (Default `Ctrl+B`), ähnlich wie tmux:

- `Ctrl+B`, dann `V` — vertikal splitten
- `Ctrl+B`, dann `-` — horizontal splitten
- `Ctrl+B`, dann Pfeiltasten — zwischen Panes navigieren
- `Ctrl+B`, dann `D` — von der Session detachen
- `Ctrl+B`, dann `X` — aktuelles Pane schließen

Du kannst all das auch mit der Maus machen — klicken, um Panes auszuwählen, Ränder ziehen zum Resizen, Rechtsklick fürs Kontextmenü.

Lege von Anfang an eine benannte Session an:

```bash
herdr session attach my-workspace
```

### Mehrere Coding-Agents gleichzeitig laufen lassen

Hier verdient Herdr seinen Platz. Öffne mehrere Panes und starte in jedem einen anderen Agent:

```bash
# Pane 1: Claude Code for architecture
claude

# Pane 2: Codex for implementation
codex

# Pane 3: Copilot CLI for quick edits
copilot
```

Die Agent-State-Sidebar rechts zeigt in Echtzeit, was jeder Agent tut. Wenn Claude Code auf deinen Input wartet, kippt sein Zustand mit einem Indikator auf „blocked". Wenn Codex Code generiert, zeigt es „working". Ein Blick auf die Sidebar und du weißt sofort, welches Pane deine Aufmerksamkeit braucht.

Besonders nützlich ist das, wenn du einen Lead-Agenten plus Helper-Agents fährst. Der Lead bearbeitet die Hauptaufgabe, während Helper parallel an Subtasks arbeiten — und du siehst all ihre Zustände auf einmal.

### Agent-Integrationen installieren

Für bessere State-Erkennung installierst du Integrationen für deine Agents:

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

Integrationen fügen Hooks hinzu, die reichhaltigere State-Informationen melden. Ohne Integrationen nutzt Herdr Prozessnamen-Matching und Terminal-Output-Heuristiken — was funktioniert, aber Integrationen geben dir granulareren Status (z. B. „generating code" vs. „waiting for tool approval" vs. „idle").

---

## Wie ich Herdr tatsächlich nutze (Video-Walkthrough)

Video: [How I Use Herdr Day to Day — Hands-On Walkthrough](https://www.youtube.com/embed/wwCDi3kN0ck)

Ich habe ein komplettes Walkthrough meines täglichen Herdr-Setups aufgenommen. Die kurze Version: Ich nutze einen kleinen Ausschnitt dessen, was Herdr kann, und dieser Ausschnitt ist der Grund, warum es den ganzen Tag offen bleibt.

**Es hat tmux für mich ersetzt — wegen der Maus.** Ich bin mit tmux nie warm geworden, weil ich gerne mit der Maus arbeite, nicht nur mit der Tastatur. Herdr gibt dir Spaces und Panes, die du per Klick hinzufügst, per Ziehen resizt und aus einem Menü schließt. Keybindings und Tabs gibt es auch, und beide Eingabestile funktionieren nebeneinander.

**Ich fahre die Defaults und sonst nichts.** Die Doku behandelt Integrationen, Plugins, einen File-Viewer, Neovim-Bindings, Workflows. Ich nutze nichts davon. Mein ganzer Loop: `herdr` laufen lassen, einen sauberen Workspace bekommen, einen Agent in einem Pane starten.

**Agents werden mit null Config erkannt.** Wenn ich eine [Oh My Pi (OMP)](https://omp.sh/)-Instanz in einem Pane starte, greift Herdr sie automatisch auf und benachrichtigt mich in dem Moment, in dem der Agent meinen Input braucht.

**Agents können Herdr selbst steuern.** Im Video bitte ich OMP, ein Panel zu öffnen und freien Speicherplatz zu prüfen. Es liest den Herdr-Skill (mit einem Befehl installiert), fährt sein eigenes Pane hoch und führt die Befehle aus, ohne dass ich etwas anfasse. Später im Video öffnet es eine zweite OMP-Instanz in einem neuen Panel und schickt Arbeit dorthin. Das ist die Orchestrierungs-API aus dem nächsten Abschnitt, erreicht durch schlichte Konversation.

**Das Fenster zu schließen ändert nichts.** Das ist der Teil, der mir am wichtigsten ist: Schließ das Terminal mitten im Task und der Agent arbeitet weiter. `herdr` nochmal ausführen und alles ist da, wo du es verlassen hast — dieselben Spaces, dieselben Panes, dieselben Agents laufen noch.

**Meine Agents leben auf einem VPS.** Ich fahre `herdr --remote` mit einem SSH-Config-Alias (exakt das Setup aus dem [Remote-Attach-Abschnitt](#remote-ssh-attach)), sodass meine Projekte auf dem Server immer am Leben sind. Laptop zu, Akku leer, unterwegs — die Arbeit läuft auf dem VPS weiter, und ich attache von welchem Gerät auch immer vor mir liegt. Am Tag vor der Aufnahme habe ich ein paar Millionen Tokens für ein Projekt-Update verbrannt, während ich kaum zugeschaut habe.

**Es gibt auch eine Desktop-App.** Herdr M (macOS) packt dieselben Sessions in eine reguläre UI: alle deine Spaces, Dateizugriff und Remote-Verbindungen in einem Fenster. Geräte sind verknüpft, sodass ich, wenn ich Ghostty mitten im Task schließe, dieselbe Session in der App wieder aufnehmen kann. Ich bin ein Terminal-Mensch und nutze sie selten, aber es ist der freundlichste Einstieg, wenn die TUI nicht dein Ding ist.

Im Alltag ist das lokal Ghostty, und auf dem VPS ein TUI-File-Manager mit Herdr verschachtelt darin. Nichts davon ist Pflicht — es ist einfach das, was hängen geblieben ist. Wenn du Herdr anders nutzt, besonders das Plugin-Ökosystem, sag es mir in den Kommentaren unter dem Video.

---

## Herdr-Socket-API und Agent-Orchestrierung

Das ist das Feature, das Herdr von jedem anderen Terminal-Multiplexer unterscheidet. Agents können das Terminal programmatisch über eine Socket-API steuern.

![Agent-Orchestrierungs-Flussdiagramm: Lead-Agent nutzt die Socket-API, um Helper-Agents zu erstellen, State zu überwachen und Output zu lesen](@assets/images/26/07/orchestration-flowchart.webp)

Statt nur in Panes zu laufen, können Agents:

- **Neue Panes erstellen** — Helper-Agents bei Bedarf hochfahren
- **Befehle ausführen** — Shell-Befehle in jedem Pane ausführen
- **Output lesen** — stdout aus anderen Panes abgreifen
- **Auf State warten** — blockieren, bis ein anderer Agent einen bestimmten Zustand erreicht (done, idle etc.)
- **Splitten und attachen** — das Workspace-Layout programmatisch verwalten

So sieht Orchestrierung von der CLI aus:

```bash
# 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
```

**Agent-gesteuerte Orchestrierung**

Kein anderer Terminal-Multiplexer bietet das. tmux hat Scripting-Fähigkeiten und Zellij eine Plugin-API, aber keins von beiden versteht Agent-States. Herdrs Socket-API lässt Agents miteinander koordinieren — ein Lead-Agent kann Helper hochfahren, auf Ergebnisse warten und weitermachen. Wenn du daran interessiert bist, [deinen eigenen AI-Agent zu bauen](/build-ai-agent-mastra/), der sich mit dieser API integrieren könnte, eröffnet das echte Orchestrierungs-Workflows.

Praktische Anwendungsfälle:

- **Lead-Agent + Helper:** Ein Agent führt die Hauptaufgabe aus, spawnt Helper-Agents für Subtasks (Linting, Testing, Dokumentation) und wartet, bis sie fertig sind.
- **Automatisierte Test-and-Fix-Loops:** Ein Agent führt Tests aus, liest den Output, fixt Fehler und wiederholt — alles über die Socket-API.
- **Multi-Repo-Workflows:** Verschiedene Agents arbeiten parallel an verschiedenen Repositories, koordiniert von einem Lead-Agenten.

---

## Herdr vs. tmux vs. Zellij

Das ist der Vergleich, den die meisten sehen wollen. Hier eine ehrliche Aufstellung:

| Feature | Herdr | tmux | Zellij |
|---------|-------|------|--------|
| Agent-State-Bewusstsein | Ja (blocked/working/done/idle) | Nein | Nein |
| Maus-native UI | Ja | Teilweise (braucht Config) | Ja |
| Agent-förmige API | Ja (read, send, wait, split) | Terminal-Scripting | Plugin-Scripting |
| SSH-Attach | Ja | Ja | Ja |
| Reife des Plugin-Ökosystems | Jung (~105 Tage) | Sehr ausgereift (18 Jahre) | Wachsend |
| Session-Resurrection | Noch nicht | Ja (via Plugins wie tmux-resurrect) | Eingebaut |
| Statusleisten-Widgets | Agent-fokussiert | Akku, CPU, Wetter etc. | Eingebaute Tabs |
| Eingebautes Sandboxing | Nein | Nein | Ja |
| Konfigurations-Komplexität | Niedrig | Hoch | Mittel |

### Herdr-Stärken

- Agent-State-Sidebar — das Killer-Feature, das tmux und Zellij nicht matchen können
- Socket-API für Agent-Orchestrierung — wirklich neu
- Maus-first-Design — keine Config nötig
- Einzelne Binary, null Dependencies
- Remote-Thin-Client-Modus
- Arbeitet mit deinem bestehenden Terminal (ersetzt es nicht)

### tmux-Stärken

- 18 Jahre kampferprobte Stabilität
- Riesiges Plugin-Ökosystem (tmux-resurrect, tmux-continuum, tmuxinator)
- Statusleisten-Widgets für alles (Akku, CPU, Netzwerk, Wetter)
- Session-Resurrection und Auto-Save
- Auf jedem Unix-System per Default oder Paketmanager verfügbar
- Tiefe Anpassung mit `.tmux.conf`

### Zellij-Stärken

- Eingebaute Floating Panes und Session-Management
- Layout-System mit YAML-Dateien
- Eingebautes Sandboxing für Plugins
- Session-Resurrection out of the box
- Wachsendes Plugin-Ökosystem mit Web-Technologien
- Intuitivere Default-Keybindings (kein Prefix-Modus)

**Wann tmux immer noch die bessere Wahl ist:** Wenn du eine tief angepasste `.tmux.conf` hast, auf spezifische tmux-Plugins angewiesen bist oder 18 Jahre Muskelgedächtnis um tmux-Keybindings herum aufgebaut hast, hat der Wechsel zu Herdr reale Kosten. tmux ist außerdem die sicherere Wahl für das Management von Produktionsservern, wo Stabilität mehr zählt als Features.

**Wann Herdr gewinnt:** Wenn du mehrere AI-Coding-Agents fährst und Echtzeit-Sichtbarkeit willst, was sie gerade tun, gibt es keine Alternative. Die Agent-State-Sidebar allein rechtfertigt den Wechsel für Multi-Agent-Workflows. Die Socket-API ist ein Bonus, der Orchestrierungsmuster eröffnet, die tmux schlicht nicht kann.

Für das breitere Feld — Zellij, Rex, Tern und TuiOS inklusive — sieh unseren [Sechs-Wege-Terminal-Multiplexer-Vergleich](/de/beste-terminal-multiplexer/).

---

## Herdr-Plugins und Community-Ökosystem

Das Plugin-Ökosystem ist jung, wächst aber schnell. Es gibt schon 83+ öffentliche Repositories mit dem Tag „herdr" auf GitHub.

Nennenswerte Community-Plugins:

- **herdr-plus** — Fügt Quick Actions (vordefinierte Command-Templates) und eine Projects-Ansicht zum Organisieren von Workspaces hinzu
- **herdr-file-viewer** — Ein git-bewusster File-Viewer-TUI (64 GitHub-Sterne). Dateien durchstöbern, Diffs sehen und durch dein Projekt navigieren, ohne Herdr zu verlassen
- **herdr-reviewr** — Code-Review-Sidebar (44 Sterne). Pull Requests direkt in Herdr reviewen
- **ccgram** — Telegram-Bridge für Herdr (202 Sterne). Benachrichtigungen auf Telegram bekommen, wenn Agents fertig werden, blockieren oder Fehler werfen
- **vim-herdr-navigation** — Vim-/Neovim-Integration für Pane-Navigation
- **pi-bellwether** — Paketmanager-Integration für Herdr-Verwaltung

Third-Party-Tools entstehen ebenfalls:

- **Moshi** — Eine iOS-Terminal-App mit nativem Herdr-Support. Verwalte deine Agent-Panes von einem iPhone aus.
- **Agentchute** — Intra-Agent-Kommunikationsschicht, die mit Herdrs Socket-API arbeitet

Das Ökosystem ist ungefähr da, wo tmux in seinem ersten Jahr war. Die Plugin-Zahl wächst schnell (von null auf 83 Repos in ~105 Tagen), und die Qualität der Top-Plugins ist schon ordentlich. Rechne damit, dass das bei der Wachstumskurve des Projekts schnell reift.

---

## Wer Herdr nutzen sollte (und wer nicht)

**Herdr ist super, wenn...**

- Du 3+ AI-Coding-Agents gleichzeitig fährst und den Überblick verlierst, welche Aufmerksamkeit brauchen
- Du auf Remote-Servern via SSH arbeitest und ein terminal-natives Tool willst (kein Electron, keine Web-UI)
- Du auf Linux oder macOS bist und Tools bevorzugst, die in deinem bestehenden Terminal laufen
- Du null Telemetrie, keine Accounts und eine einzelne Binary ohne Dependencies willst
- Du an Agent-Orchestrierung interessiert bist — Agents, die über eine Socket-API koordinieren
- Du VPS-Infrastruktur verwaltest und SSH-first-Tooling willst — wenn du [Self-Hosted-Server-Panels](/best-self-hosted-panels/) fährst, passt Herdr zu dieser Philosophie

**Zieh Alternativen in Betracht, wenn...**

- Du ein tmux-Power-User mit tief angepasster Config und 18 Jahren Plugin-Abhängigkeiten bist. Die Migrationskosten sind real.
- Du nur auf Windows bist. Der Support ist Beta und hat noch raue Kanten.
- Du produktionsreife Stabilität für kritische Workflows brauchst. Herdr ist 105 Tage alt und pre-1.0.
- Du eingebautes Sandboxing oder Prozess-Isolation brauchst. Herdr sandboxed Agents nicht.
- Du eine GUI bevorzugst, die dein Terminal ersetzt (Warp, cmux, Conductor, [Tern](/de/tern-terminal/)). Herdr ist by design terminal-nativ.
- Du kostenbewusst bist und Herdr mit [günstigen AI-Modellen](/de/guenstige-hermes-agent-modelle/) kombinieren willst — das funktioniert, aber die Ersparnis kommt von den Modellen, nicht von Herdr selbst.

---

## Lizenzierung und Preise

Herdr ist unter **AGPL-3.0-or-later** lizenziert — kostenlos für persönliche und kommerzielle Nutzung. Du kannst es herunterladen, laufen lassen und modifizieren, ohne etwas zu zahlen.

**Hinweis zur Lizenz**

AGPL bedeutet: Wenn du Herdr modifizierst und es verteilst (oder als Netzwerk-Service betreibst), musst du deine Modifikationen unter derselben Lizenz teilen. Für die typische Nutzung — lokal laufen lassen, um deine Agents zu verwalten — hat das keine praktischen Auswirkungen. Es ist kostenlos, es funktioniert, du schuldest niemandem etwas.

Wenn deine Organisation AGPL nicht einhalten kann (manche Enterprise-Policies verbieten es), gibt es eine kommerzielle Lizenz. Kontaktiere hey@herdr.dev für Preise. Eine öffentliche Preisseite existiert nicht.

Die wichtigsten Lizenz-Details:

- **Null Telemetrie** — kein Phone-home, keine Analytics, kein Usage-Tracking
- **Kein Account nötig** — laden und laufen lassen. Keine Cloud-Abhängigkeit.
- **Kein Vendor-Lock-in** — es ist eine Standard-Rust-Binary. Wenn du aufhörst, es zu nutzen, sind dein Terminal und deine Agents unberührt.

Für Kontext zum breiteren Open-Source-AI-Ökosystem sieh unseren Guide zu [Open-Source-LLMs für Coding](/de/beste-open-source-llms-claude-alternativen/) — Open-Source-Modelle mit einem Open-Source-Terminal-Multiplexer zu fahren ist so vendor-neutral, wie es wird.

---

## Risiken und was du wissen solltest

**Pre-1.0-Software**

Herdr ist ungefähr 105 Tage alt (Stand Juli 2026). Es bewegt sich schnell, was heißt: Features shippen schnell, aber Breaking Changes sind möglich. Setz dir ein Datum, zu dem du es erneut anschaust.

Ehrliche Vorbehalte:

1. **Junges Projekt.** Pre-1.0, ~105 Tage alt. APIs und Features können sich ändern. Wenn du Workflows um die Socket-API baust, rechne mit etwas Anpassungsbedarf, während das Projekt sich weiterentwickelt.
2. **Solo-Entwickler.** Bus-Faktor ist 1. Ogulcan Celik arbeitet fulltime daran, aber es steht kein Team dahinter. Die Community (fast 15.000 Sterne) hilft, aber die Kernentwicklung hängt an einer Person.
3. **Fehlende tmux-Features.** Keine Akku-/CPU-Statusleisten-Widgets. Kein Session-Resurrection-Äquivalent zu tmux-resurrect. Keine tmuxinator-artigen Projekt-Templates (noch).
4. **Performance bei großen Setups.** Einige User auf Hacker News berichteten Text-Rendering-Verzögerung bei vielen offenen Panes. Deine Erfahrung kann bei 10+ Panes variieren.
5. **Kein eingebautes Sandboxing.** Agents laufen mit deinen User-Rechten. Wenn ein Agent etwas Destruktives tut, hält Herdr ihn nicht auf.
6. **Keine öffentlichen Enterprise-Preise.** Organisationen müssen für ein Angebot mailen — kein Self-Serve.
7. **Lernkurve bei den Keybindings.** Das Prefix-basierte Modell ist tmux-Usern vertraut, aber die konkreten Bindings unterscheiden sich. Rechne mit ein paar Tagen Eingewöhnung.

Das schnelle Community-Wachstum (15.000+ Sterne, 83+ Repos, aktiver Discord) mildert einige dieser Risiken. Tools, die echte Probleme lösen, ziehen tendenziell Contributors an und überleben.

---

## Fazit

Herdr ist der erste Terminal-Multiplexer, der AI-Coding-Agents tatsächlich versteht. Wenn du mehrere Agents fährst und den Überblick verlierst, welche dich brauchen, ist die Agent-State-Sidebar allein den Wechsel wert.

Es ist noch kein tmux-Ersatz — nicht für Power-User mit tiefem Anpassungsbedarf. tmux hat 18 Jahre Ökosystem-Reife, Herdr hat 105 Tage. Aber für den spezifischen Anwendungsfall von Multi-Agent-Terminal-Workflows kommt nichts anderes heran.

Die Socket-API ist neu. Kein anderer Terminal-Multiplexer lässt Agents programmatisch koordinieren — Panes erstellen, Output lesen, auf State warten. Das eröffnet Orchestrierungs-Workflows, die mit tmux oder Zellij nicht möglich sind.

Die ehrliche Empfehlung: Probier es bei deiner nächsten Multi-Agent-Session. Fahr Herdr einen Tag mit drei oder vier Agents, beobachte die State-Sidebar und schau, ob es deine Arbeitsweise ändert. Wenn nicht, ist tmux immer noch da. Wenn ja, bleibst du wahrscheinlich dabei.

[Herdr auf GitHub ausprobieren](https://github.com/ogulcancelik/herdr)
[herdr.dev besuchen](https://herdr.dev/)

Wenn du außerdem [günstige AI-Modelle](/de/guenstige-hermes-agent-modelle/) erkundest, die du mit Herdr kombinieren kannst, oder allgemeiner auf [AI-Coding-Tools und -Assistants](/ai-coding-tools/) schaust, haben wir für beides Guides. Und wenn eine Terminal-UI nicht reicht, liefert das Projekt inzwischen eine native Desktop-App, deren gesamtes Interface dein Agent umbauen kann — sieh dir unseren Rundgang durch die [Herdr-App-Galerie, Layouts und Mods](/de/herdr-app-layouts-und-mods/) an.

---

## FAQ

**Ist Herdr kostenlos?**

Ja. Herdr ist unter AGPL-3.0-or-later lizenziert — kostenlos für persönliche und kommerzielle Nutzung. Kein Account, kein Abo, keine Cloud-Abhängigkeit. Eine kommerzielle Lizenz gibt es für Organisationen, die AGPL nicht einhalten können (Kontakt: hey@herdr.dev).

**Ersetzt Herdr tmux?**

Noch nicht für Power-User. Herdr fügt Agent-Bewusstsein und Orchestrierung hinzu, die tmux fehlen, aber tmux hat 18 Jahre Plugins, Konfigurationsoptionen und kampferprobte Stabilität. Herdr ist besser für Multi-Agent-Workflows; tmux ist besser für etablierte, stark angepasste Setups. Viele Entwickler fahren beides — tmux für allgemeines Server-Management, Herdr für Agent-Sessions. Separat im Blick zu behalten: [Superlogical Rex](/de/superlogical-rex/), das Terminal-als-Multiplexer-Projekt vom Ghostty-Schöpfer, das den gegenteiligen Ansatz zu Herdr verfolgt (das Terminal selbst ist der Multiplexer; vorerst macOS-only), und [Tern](/de/tern-terminal/), Stencils Rust-natives Workspace-Terminal — das Herdr über ein Community-Plugin sogar in einem Pane laufen lassen kann.

**Welche AI-Coding-Agents unterstützt Herdr?**

14+ Agents out of the box, darunter Claude Code, Codex, Copilot CLI, Gemini CLI, Grok CLI, Cursor Agent, Pi, Droid, Amp, OpenCode, Antigravity CLI, Kimi Code CLI, [Hermes Agent](/hermes-agent-setup-guide/), QoderCLI, Kiro CLI und mehr. Wenn dein Agent nicht gelistet ist, funktioniert die generische Prozess-Erkennung meist — du bekommst ohne Integration nur kein granulares State-Reporting.

**Kann ich Herdr über SSH auf einem Remote-Server nutzen?**

Ja. Zwei Optionen: (1) Herdr auf dem Server installieren und normal per SSH rein — die TUI rendert über SSH. (2) `herdr --remote ssh://user@server` für den Thin-Client-Modus nutzen, der Rendering-Daten streamt und auf langsamen Verbindungen reaktiver ist. Die Moshi-iOS-Terminal-App hat außerdem nativen Herdr-Support für mobilen Zugriff.

**Funktioniert Herdr auf Windows?**

Der Windows-Support ist aktuell in Beta. Linux und macOS sind die primären Plattformen und voll unterstützt. Wenn du Windows-only bist, rechne mit gelegentlichen rauen Kanten. Die Beta ist funktional genug für die Basisnutzung, aber noch nicht auf Feature-Parität mit den Unix-Builds.

**Wie erkennt Herdr Agent-States?**

Über zwei Schichten. Erstens Prozessnamen-Matching — Herdr erkennt die Binary-Namen unterstützter Agents (claude, codex, copilot etc.) und leitet Basis-State aus Terminal-Output-Mustern ab. Zweitens installieren Agent-Integrationen (`herdr integration install `) Hooks, die direkt reichhaltigere State-Informationen melden. Integrationen geben dir granulareren Status (z. B. „waiting for tool approval" vs. „generating code") als Heuristiken allein.

Herdr passt zu den Coding-Agents aus den [Top-AI-GitHub-Repos](/de/top-ki-github-repos/) (OpenCode, Pi, Cline, OpenHands).