---
title: "Die besten Herdr-Plugins (2026): 10 geprüfte Picks, die sich lohnen"
description: "Die besten Herdr-Plugins, die sich 2026 zu installieren lohnen: 10 geprüfte Picks für Agent-Review, Usage und Remote Control, plus Installations- und Prüf-Workflow."
date: 2026-10-08
categories: ["ai"]
tags: ["herdr","plugins","terminal"]
---

Der Herdr-Plugin-Marketplace ist jung, riesig und komplett ungeprüft: grob 1.000+ indexierte Plugins und etwa 1.500 Repos mit Tag `herdr-plugin` auf GitHub, Stand 2026-10-08. Ein Plugin läuft als dein User mit deiner kompletten Umgebung – blind installieren ist also eine schlechte Idee. Was folgt, ist meine Auswahl der besten Herdr-Plugins, die sich zu installieren lohnen, samt Install-/Pin-/Verify-Befehlen, plus der Prüf-Workflow für den Rest des Herdr-Plugin-Marketplace. Wenn du neu bei der Runtime bist, lies zuerst [unser Herdr-Review (Open-Source-Agent-Multiplexer)](/herdr-agent-multiplexer/) und dann die [besten AI-Coding-Tools und Agents 2026](/ai-coding-tools/), die diese Plugins beobachten. Noch am Runtime-Wählen? Der [Sechs-Wege-Multiplexer-Vergleich](/de/beste-terminal-multiplexer/) stellt Herdr gegen tmux, Zellij, Rex, Tern und TuiOS.

## Was sind Herdr-Plugins?

Ein Herdr-Plugin ist ein Verzeichnis mit einem `herdr-plugin.toml`-Manifest plus Befehlen, die Herdr als argv-Arrays startet. Das ist das ganze Modell. Es gibt kein SDK und keine eingeschränkte API-Oberfläche: Die komplette `herdr`-CLI ist die Plugin-API, und Plugins rufen über `HERDR_BIN_PATH` zurück – das funktioniert über Unix-Sockets und Windows-Named-Pipes gleichermaßen. Jede Sprache geht, weil Herdr einfach exec't, was das Manifest deklariert: Bash, JavaScript, Lua, Rust, Go, Python, PowerShell.

Der Herdr-Plugin-Marketplace auf `herdr.dev/plugins` ist kein Katalog, den irgendjemand reviewed hätte. Es ist ein automatischer Index öffentlicher GitHub-Repositories mit dem Tag `herdr-plugin`, alle 30 Minuten aktualisiert. Forks, archivierte Repos und Repos, deren Manifeste nicht parsen, sind ausgeschlossen. Alles andere taucht auf.

**Kein Sandbox, kein Review**

  Die offiziellen Docs sagen es klar: „A plugin is ordinary code that runs on your machine." Herdr validiert die Manifest-Felder und sonst nichts. Es „does not review or sandbox plugin code." Ein Plugin läuft als dein User, mit deinen Umgebungsvariablen und deinem vollen CLI-Zugriff. Prüfen ist deine Aufgabe – die Checkliste unten ist die Gegenmaßnahme.

![Herdr-Plugin-Architekturdiagramm: Manifest-Sektionen, argv-Befehle, injizierte Runtime-Umgebungsvariablen und Callbacks über die herdr-CLI](@assets/images/26/10/herdr-plugin-anatomy.webp)

Das Manifest ist der Vertrag. Pflichtfelder sind `id`, `name`, `version` und `min_herdr_version` (die Plugin-API existiert seit herdr 0.7.0, und Herdr lehnt ein Plugin ab, das eine neuere Binary verlangt als die, die du fährst). Die optionalen Sektionen decken die interessanten Teile ab: `[[build]]` kompiliert Dinge bei GitHub-Installs, `[[startup]]` führt einmalige Initialisierung nach Session-Restore aus und läuft bei Live-Handoff erneut, `[[actions]]` sind benannte Befehle, die du aufrufen oder auf Keys binden kannst, `[[events]]` feuern auf Dinge wie `on = "worktree.created"`, `[[panes]]` platzieren eine UI (standardmäßig Overlay, oder `popup`, `split`, `tab`, `zoomed`), und `[[link_handlers]]` machen aus Ctrl+Klick auf eine URL eine Aktion via Rust-Regex.

Zur Laufzeit injiziert Herdr `HERDR_SOCKET_PATH`, `HERDR_BIN_PATH`, `HERDR_ENV=1`, `HERDR_PLUGIN_ID`, `HERDR_PLUGIN_ROOT`, `HERDR_PLUGIN_CONFIG_DIR`, `HERDR_PLUGIN_STATE_DIR` und `HERDR_PLUGIN_CONTEXT_JSON`. Merke dir eine Regel zu diesen Pfaden: `HERDR_PLUGIN_ROOT` ist ein verwalteter Checkout, den eine Neuinstallation ersetzt. Lagere dort niemals Credentials. Config- und State-Verzeichnisse gehören dir.

Die Größenordnung ist wichtig dafür, wie du stöberst. Die GitHub-Topic-Seite listet etwa 1.500 öffentliche Repositories, Stand 2026-10-08 – darunter Dotfiles-Sammlungen und aus anderen Ökosystemen mitgetaggte Tools. Der kuratierte Index auf herdr.dev zeigt nur Repos mit parsebaren Manifesten auf dem Default-Branch, was den echten Marketplace bei grob 1.000+ Einträgen ansiedelt. Entdeckt wird entweder über den Index oder die GitHub-Topic-Suche – genauso, wie du [Top-AI-GitHub-Repos, die einen Star verdienen](/de/top-ki-github-repos/), durchstöbern und hart filtern würdest.

Kostencheck, bevor wir weitermachen: Alles in diesem Artikel ist kostenlos und lokal. Kein Account, keine GPU, keine Datenbank, kein Abo. Die einzige optionale Ausgabe ist ein kleiner VPS, falls Agents 24/7 laufen sollen – dazu am Ende mehr.

Video: [5 JAW-DROPPING Herdr Plugins!!!](https://youtube.com/embed/29KAoidwCUA)

So sieht die meiste Plugin-Berichterstattung aus: Begeisterung, keine Befehle, kein Trust-Workflow. Die Picks unten sind die geprüfte, Befehle-zuerst-Version.

Ein Naming-Hinweis vor den Picks: Plugins erweitern den **Terminal-Multiplexer** aus unserem [Herdr-Review](/herdr-agent-multiplexer/). Die neuere native Desktop-App hat ein eigenes Extension-System – JavaScript-**Mods** und JSON-**Layouts**, die das Fenster selbst umbauen und unter den GitHub-Topics `herdr-mod`/`herdr-layout` statt `herdr-plugin` veröffentlicht werden. Dieselben Trusted-Code-Regeln gelten (ein Mod läuft als du, ungeprüft). Unser [Herdr-App-Layouts-&-Mods-Rundgang](/herdr-app-layouts-mods/) deckt dieses Ökosystem ab.

## Herdr-Plugins sicher installieren

Herdr-Plugins zu installieren ist ein Befehl. Sie ohne Reue zu installieren, kostet vorher fünf Minuten Lesen. Der Operator-Flow ist: Voraussetzungen, prüfen (die volle Checkliste ist ein eigener Abschnitt weiter unten), mit Preview installieren, die geprüfte Revision pinnen, verifizieren und den Rollback-Pfad kennen.

### Voraussetzungen (was du brauchst)

Herdr 0.7.0 oder neuer, weil die Plugin-API damit kam. Einzelne Plugins können mehr verlangen: herdr-reviewr braucht >= 0.7.5, und der herdr-web-ui-Installer erwartet 0.9.0+. Git, weil `plugin install` ein Repository klont. Und welche Toolchain das Plugin auch immer baut: node oder bun für TypeScript-Plugins, Go für die herdr-plus- und tsk-Fraktion, cargo für die Rust-TUIs. Herdr installiert keine Toolchains für dich. Ein fehlendes `cargo` zeigt sich als fehlgeschlagener Build-Step, der die Registrierung abbricht.

  

    
- herdr >= 0.7.0, bestätigt mit `herdr --version`
    
- git auf dem PATH (der Install klont das Repo)
    
- die Toolchain, mit der dein Pick baut: node/bun, go oder cargo
    
- 5 Minuten Zeit, das `herdr-plugin.toml` des Repos zu lesen, bevor du installierst
  

### Mit Preview installieren, eine Revision pinnen

1. Stöbere im Index auf https://herdr.dev/plugins oder suche auf GitHub nach `topic:herdr-plugin`.
2. Öffne das Repo und lies `herdr-plugin.toml` vor allem anderen. Wenn die Befehle falsch aussehen, hör hier auf.
3. Führe `herdr plugin install owner/repo[/subdir]` aus. In einem interaktiven Terminal zeigt Herdr eine Vorschau der Quelle und der Befehle, die es gleich ausführen wird. Lies sie. **Gib bei einer Erstinstallation niemals `--yes` an.**
4. Pinne, was du geprüft hast: `herdr plugin install owner/repo --ref v1.2.0`. Der Pin ist dein Rollback-Anker.
5. Build-Befehle laufen nur bei GitHub-Installs. Ein Build-Fehler bricht die Registrierung ab, und das Manifest nach der Vorschau zu bearbeiten, bricht den Install ab. Beides sind Features. Für lokale Entwicklung registriert `herdr plugin link /pfad` ein Verzeichnis und überspringt Builds komplett.

```bash
# install with the interactive preview
herdr plugin install persiyanov/herdr-reviewr

# install the exact revision you reviewed
herdr plugin install persiyanov/herdr-reviewr --ref v1.2.0

# local development: register a directory, no build step
herdr plugin link /home/you/src/my-herdr-plugin
```

  
### Unix

    ```bash
    # one-time install of herdr itself
    curl -fsSL https://herdr.dev/install.sh | sh

    herdr --version   # expect >= 0.7.0
    git --version
    herdr plugin install owner/repo
    ```
  

  
### Windows

    ```powershell
    irm https://herdr.dev/install.ps1 | iex

    herdr --version
    herdr plugin install owner/repo
    ```

    Unter Windows lösen Build-/Action-/Event-Befehle `PATHEXT`-Shims auf, aus `npm` und `bun` werden also korrekt `npm.cmd` und `bun.cmd`. Pane-Befehle müssen gültige Windows-argv sein; kopiere keine Unix-Shell-Syntax in ein `command`-Array.
  

**Kein Plugin-Update-Befehl**

  Plugin v1 hat kein `herdr plugin update`. „Aktualisieren" heißt, `herdr plugin install owner/repo` erneut auszuführen (optional mit neuem `--ref`), und das **ersetzt den verwalteten Checkout**. Alles, was du in `HERDR_PLUGIN_ROOT` liegen hattest, ist weg. Halte Secrets und Einstellungen in `HERDR_PLUGIN_CONFIG_DIR` – das überlebt Neuinstallationen und Deinstallationen.

### Verifizieren, dass es funktioniert

Nach jedem Install Registrierung und sauberen ersten Lauf bestätigen:

```bash
herdr plugin list --json                      # registered + enabled, with ids
herdr plugin action list --plugin plugin.id   # what actions exist
herdr plugin action invoke plugin.id.action   # run one once
herdr plugin log list --plugin plugin.id --limit 20
```

Öffne das Pane oder die Aktion des Plugins einmal und erwarte normale Ausgabe in den Logs mit Exit-Code 0. So sieht „kaputt" aus: Das Plugin fehlt in `plugin list`, ein Non-Zero-Exit in `plugin log list`, oder eine Aktion hängt, weil ihre Toolchain oder eine Config-Datei fehlt.

Um eine Aktion auf einen Key zu binden, füge sie in `~/.config/herdr/config.toml` ein und lade neu:

```toml
[[keys.command]]
key = "prefix+l"
type = "plugin_action"
command = "example.layout.apply"
description = "apply layout"
```

```bash
herdr server reload-config
```

### Rollback / Rückgängig

```bash
herdr plugin disable ID        # keep it, stop it running
herdr plugin enable ID
herdr plugin uninstall ID      # removes the managed checkout
herdr plugin unlink ID         # local dev deregistration
```

`uninstall` entfernt den verwalteten Checkout, lässt aber Config- und State-Verzeichnisse stehen – dein Rettungsweg, falls du aus Versehen deinstallierst. Zwei Eigenheiten: Über ein gelinktes Plugin zu installieren wird abgelehnt, also erst `unlink`; und auf 0.7.3 müssen Plugins, die nur innerhalb einer benannten Session registriert sind, neu gelinkt oder neu installiert werden.

Fehlerbilder in diesem Abschnitt: Ein Build-Abbruch mit gekürztem stdout/stderr ist fast immer ein fehlendes `cargo`/`npm`/`go` – Toolchain installieren und nochmal versuchen. Ein abgelehnter Install über einem lokalen Verzeichnis heißt, du bist an die Linked-Plugin-Regel geraten. Ein Abbruch nach der Vorschau heißt, das Manifest hat sich zwischen Vorschau und Bestätigung geändert – Herdr weigert sich, Code auszuführen, den du nicht gesehen hast.

## Die 10 besten Herdr-Plugins, die sich lohnen

Zehn Picks, gruppiert nach der Aufgabe, die sie erledigen. Star-Zahlen sind Schnappschüsse vom 2026-10-08, keine Vertrauenswerte. Jeder Install-Befehl ist absichtlich vollqualifiziert `owner/repo`, weil Namenskollisionen in diesem Marketplace real sind.

  

    
- Den Diff des Agents reviewen: herdr-reviewr
    
- Sehen, was der Agent angefasst hat: herdr-file-viewer
    
- Dem Agent beim Arbeiten zuschauen: zoetrope
    
- Spend und Kontext tracken: herdr-agent-usage
    
- Einen Workspace aus TOML bootstrappen: herdr-plus
    
- Tabs sinnvoll benannt halten: herdr-auto-title
    
- Alles fuzzy-navigieren: herdr-navigator
    
- Nach Crash oder Reboot wiederherstellen: herdr-resurrect
    
- Den Plugin-Zoo verwalten: herdr-plugin-manager
    
- Agents vom Handy aus steuern: collie
  

![Herdr-Marketplace-Trichterdiagramm: über tausend Plugins in sieben Aufgaben gruppiert, mit den zehn empfohlenen Picks neben jeder Aufgabe](@assets/images/26/10/herdr-marketplace-by-job.webp)

### Den Diff des Agents reviewen (herdr-reviewr)

`persiyanov/herdr-reviewr` (804 Stars) öffnet den Diff des Agents in einem Terminal-Pane und schickt Zeilenkommentare zurück an Claude Code, Codex, OpenCode und Pi. Rust, mit vorgefertigten Binaries, also kein cargo-Schritt beim Install. Es will herdr >= 0.7.5 und läuft auf macOS und Linux. Es schließt die Lücke, die zählt, sobald ein Agent Code schreibt: die zwischen „es hat Code geschrieben" und „du hast ihn gelesen". Das ist der Killer-Anwendungsfall für Herdr-Plugins überhaupt, weil die Review-Schleife neben dem Agent lebt statt in einem Browser-Tab, den du zu checken vergisst.

```bash
herdr plugin install persiyanov/herdr-reviewr
```

![herdr-reviewr in der Herdr-TUI: ein git-diff-Pane mit einem Zeilenkommentar in der Warteschlange zum Zurücksenden an den Agent](@assets/images/26/10/herdr-reviewr-ui.webp)

Trust-Hinweis: kleine Rust-Fläche, das Manifest deklariert die üblichen Aktionen und Panes, keine Überraschungen in den Command-Arrays jenseits der Review-Binary selbst. Verifizieren, indem du das Review-Pane einmal auf einem Repo mit uncommitteten Änderungen öffnest und prüfst, ob der Diff rendert – dann einen Test-Zeilenkommentar hinterlassen und zusehen, wie er im Input des Agents ankommt. So sieht „kaputt" aus: ein leeres Diff-Pane auf einem schmutzigen Working Tree, was meist heißt, dass das Plugin nicht auf den richtigen Workspace-Tab zeigt.

Wenn du es leichter willst: `jhochenbaum/herdr-hunk-diff` (143 Stars) macht Hunk-basiertes Review mit Inline-Kommentaren und weniger beweglichen Teilen. Installiert sich genauso: `herdr plugin install jhochenbaum/herdr-hunk-diff`. `plannotator/herdr-annotate` ist der Annotiere-alles-Verwandte, falls dein Feedback-Loop Terminal-Text allgemein betrifft, nicht nur Diffs.

### Sehen, was der Agent angefasst hat (herdr-file-viewer)

`smarzban/herdr-file-viewer` (636 Stars) ist ein git-bewusstes, read-only File-Tree-TUI: Baum plus Inhalt, Working-Tree-Diffs, gerendertes Markdown, Syntax-Highlighting. Read-only ist ein Feature, wenn der Agent derjenige ist, der Dateien schreibt. Du schaust, es schreibt – und du kannst im Viewer keinen Edit verschlimmheiten.

```bash
herdr plugin install smarzban/herdr-file-viewer
```

![herdr-file-viewer im Vollbild: Dateibaum links, gerenderter Dateiinhalt mit Syntax-Highlighting rechts](@assets/images/26/10/herdr-file-viewer-ui.webp)

Trust-Hinweis: Präsentationsschicht-Plugin; der riskante Teil ist, was immer es exec't, um Git-State zu lesen. Verifizieren, indem du das Tree-Pane öffnest und prüfst, ob der Working-Tree-Diff die letzte Änderung des Agents zeigt. Wenn der Baum rendert, aber Diffs leer bleiben, prüfe, ob du das Pane im selben Workspace-Tab wie das Repo geöffnet hast; das Plugin liest den Git-State seines eigenen Pane-Kontexts.

Wenn du stattdessen einen schreibfähigen Explorer im VS-Code-Stil willst: `alexarthurs/herdr-sidebar` (424 Stars) bringt Datei-Explorer, Git-Source-Control, Diffs und AI-Commit-Messages. Beachte den Unterschied vor dem Install: Es kann dein Repo verändern, herdr-file-viewer nicht.

![alexarthurs/herdr-sidebar: Datei-Explorer, Source-Control-Panel und Agent-Panes in der Herdr-Sidebar](@assets/images/26/10/herdr-sidebar-ui.webp)

### Agents beobachten und Spend tracken (zoetrope, herdr-agent-usage)

`furkankly/zoetrope` (978 Stars) zeichnet einen Live-Flow-Graph einer Claude-Code- oder Codex-Session, im Terminal oder im Browser. Rust und Ratatui. Wenn drei Agents laufen und du wissen willst, was einer gerade tut, ist das das Pane, das du öffnest.

```bash
herdr plugin install furkankly/zoetrope
```

![zoetropes Live-Flow-Graph: Agent-Knoten mit Running-/Idle-State, die durch eine Session fließen](@assets/images/26/10/herdr-zoetrope-graph.webp)

`levi-qiao/herdr-agent-usage` (168 Stars) zeigt credential-scoped AI-Usage, Kontext und Cache für Claude, Codex, Grok, Devin, Cursor und Freunde, in einer Sidebar oder Statusline. Tokenkosten sind die echte Rechnung in einem Agent-Stack. Die Plugins beobachten sie nur – aber zu beobachten ist der Unterschied zwischen einem spaßigen Wochenende und einer Überraschungsrechnung.

```bash
herdr plugin install levi-qiao/herdr-agent-usage
```

![herdr-agent-usage-Sidebar: Kontext, API- und Weekly-Usage-Anzeigen pro Agent, nach Projekt gruppiert](@assets/images/26/10/herdr-agent-usage-gauges.webp)

**Namenskollision**

  Es gibt ein anderes Repo namens `senna-lang/herdr-agent-usage` (47 Stars), das Kontext-Meter und Rate-Limits macht. Gleicher Plugin-Name, anderer Code, anderer Autor. Installiere immer per vollqualifiziertem `owner/repo` und schreib dir auf, welches du bekommen hast. Dieselbe Falle gibt es bei Auto-Titles und Browser-Plugins; siehe den Abschnitt zu den Stolperfallen.

Zoetrope verifizieren, indem du sein Pane während einer laufenden Agent-Session öffnest und erwartest, dass der Flow-Graph sich aktualisiert. herdr-agent-usage gegen einen bekannten Account verifizieren und prüfen, ob die Zahlen grob zum Dashboard des Providers passen. `hhdebb/herdr-radar` (154 Stars) ist die Alternative, wenn du brauchst: „wer arbeitet, wer wartet auf mich" – nach Projekt gruppiert, mit ausblendenden Idle-Sessions.

```bash
herdr plugin install hhdebb/herdr-radar
```

![herdr-radar-Sidebar in hellem und dunklem Theme: Agents nach Projekt gruppiert mit Working-/Idle-State](@assets/images/26/10/herdr-radar.webp)

### Workspace-Bootstrap und Navigation (herdr-plus, herdr-auto-title, herdr-navigator)

`cloudmanic/herdr-plus` (345 Stars) ist das einzige Plugin hier mit eigener Website – aus gutem Grund. Projects baut einen kompletten Workspace aus einer einzigen TOML-Datei wieder auf, die dir gehört: Tabs, Splits, Startup-Befehle. Quick Actions ist ein Fuzzy-Launcher, der in jedem Tab funktioniert, mit per-Repo-`.herdr-plus/`-Aktionsdateien. Go-Binary, eigene Docs auf herdrplus.com, Homebrew-Tap, wenn du es so willst.

```bash
herdr plugin install cloudmanic/herdr-plus
```

![herdr-plus-Projects-Picker: eine Fuzzy-Liste von Workspaces, nach Projekt gruppiert, über einem Pane geöffnet](@assets/images/26/10/herdr-plus-projects.webp)

Die Website wirbt mit Default-Keys auf Prefix + hoch/runter nach dem Binden. Prüfe das Binding in `~/.config/herdr/config.toml`, falls es nicht reagiert, dann `herdr server reload-config`. Verifizieren, indem du ein Zwei-Tab-Projekt-TOML definierst, neu startest und prüfst, ob das Layout zurückkommt. Der Teil „TOML, das dir gehört", hat mich überzeugt: kein versteckter State, keine Datenbank – das Layout lebt in einer Datei, die du in deine Dotfiles committen und um 2 Uhr nachts von Hand editieren kannst, wenn ein Pane am falschen Platz sitzt.

`kryptamine/herdr-auto-title` (238 Stars) benennt Tabs und Panes automatisch aus Git-Branch, Terminal-Aktivität und Claude-Code-Sessions. Bei 10+ Panes ist das kein Nice-to-have, sondern die Art, wie du irgendetwas wiederfindest.

```bash
herdr plugin install kryptamine/herdr-auto-title
```

![herdr-auto-title: Tab-Leiste mit generierten Namen wie claude-1:oauth und Git-Branch-Titeln statt generischer Pane-Nummern](@assets/images/26/10/herdr-auto-title-ui.webp)

`thanhdat77/herdr-navigator` (178 Stars) ist ein Fuzzy-Navigator für Workspaces, Agents, Projekte, Remotes und Verzeichnisse. Wenn du schon in einem Fuzzy-Jumper wie [smarterer Terminal-Navigation mit zoxide](/zoxide/) lebst, ist das dasselbe Muskelgedächtnis auf Herdrs Objektmodell angewandt.

```bash
herdr plugin install thanhdat77/herdr-navigator
```

![herdr-navigators Fuzzy-Finder-Popup, das Workspaces, Agents, Projekte und Verzeichnisse über einem Live-Pane matcht](@assets/images/26/10/herdr-navigator-fuzzy.webp)

Eine Erwähnung für die Audit-geneigten: `qu8n/herdr-automatic-rename` (209 Stars) ist der Plain-Shell-Zwilling von auto-title und wahrscheinlich das einfachste Plugin in diesem ganzen Artikel zum End-to-End-Lesen. Guter Kandidat für „erstes Plugin, das du prüfst".

### Crash-Recovery und Plugin-Verwaltung (herdr-resurrect, herdr-plugin-manager)

`ntindle/herdr-resurrect` (37 Stars) ist tmux-resurrect für Herdr: Es snapshotet Workspaces, Tabs, Panes, cwd, Programme und Agents und stellt sie nach einem Crash oder Reboot wieder her. Die Star-Zahl ist niedrig, der Wert nicht. Eine 12-Pane-Agent-Farm an einen Reboot zu verlieren, ist ein schlechter Nachmittag. Snapshots triggern auf die Events, die das Plugin deklariert, und Restore läuft über dieselbe herdr-CLI wie alles andere – es gibt keinen separaten Daemon zu babysitten.

```bash
herdr plugin install ntindle/herdr-resurrect
```

`speardragon/herdr-plugin-manager` (51 Stars) verwaltet installierte Plugins aus einem Popup: installieren, enablen, deinstallieren, den Marketplace browsen. Standard-Binding ist `prefix+p`.

```bash
herdr plugin install speardragon/herdr-plugin-manager
```

![herdr-plugin-manager-Popup: Liste installierter Plugins mit Aktionen pro Plugin und einem nach Stars sortierten Marketplace-Browser](@assets/images/26/10/herdr-plugin-manager.webp)

Stolperfalle: Popups sind Singleton-Session-Ressourcen. Sie haben keine Pane-ID und keine Lifecycle-Events und liefern `ui_busy`, wenn ein Settings- oder Copy-Mode-Modal offen ist. Das ist Herdr, kein kaputtes Plugin.

Snapshots sind keine Backups. Versioniere deine `config.toml` und den Inhalt von `HERDR_PLUGIN_CONFIG_DIR` jedes Plugins in Git oder mit [Self-Hosted-Backups per Restic](/pluton-self-hosted-backup/). Plugin-Code selbst installiert sich aus gepinnten Refs neu und muss deshalb nicht in deinem Backup-Set leben.

### Agents vom Handy aus erreichen (collie)

`AltanS/collie` (1.256 Stars) ist eine self-hosted PWA, die Claude Code, Pi, Codex und OpenCode steuert – laufend in Herdr, tmux oder zellij – von deinem Handy aus. Push-Alerts, Tailscale als Default, kein App Store involviert. Es ist der beliebteste Remote-Client im Plugin-Bereich und mein Pick, wenn die Maschine zu Hause hinter Tailscale bleibt.

```bash
herdr plugin install AltanS/collie
```

![Collies Handy-UI: Agent-Inbox nach Projekt gruppiert mit Zählern für needs-you, unseen, working, done und idle](@assets/images/26/10/collie-dashboard.webp)

**Remote-Plugins sind Angriffsfläche**

  Diese Plugins exposen Live-Terminal- und Agent-Sessions über Tunnels, Relays oder Bots. Bevorzuge Tailscale (Free Tier) oder einen Cloudflare-Tunnel gegenüber jedem offenen Inbound-Port. Behandle Relay-Tokens wie Secrets. Und prüfe Lizenzen neu, bevor du auf diesen Repos aufbaust: `0cv/herdr-mobile-relay` und `dcolinmorgan/herdr-remote` zeigen beide NOASSERTION-Lizenzen, Stand 2026-10-08.

Wenn collie nicht passt: `0cv/herdr-mobile-relay` (287 Stars) macht Mobile-Web plus QR-Setup und Multi-Computer-Relays via Cloudflare – mit dem Lizenzvorbehalt oben. `devswha/herdr-web-ui` (284 Stars) ist die Browser-first-Option: Chat und ein Live-Terminal pro Pane, Remote-Maschinen über SSH, Web-Push. Für das komplette Remote-Client-Bild (Web-UIs, Handy-Apps, Desktop-Apps) siehe den Begleitartikel zu den [besten Herdr-Clients](/best-herdr-clients/).

**Affiliate-Hinweis**

  Einige Links in dieser Anleitung sind Affiliate-Links. Wenn du darüber kaufst, erhalten wir möglicherweise eine kleine Provision – ohne zusätzliche Kosten für dich. Das hilft uns, diese Empfehlungen weiter zu testen und zu aktualisieren.

Wenn die Maschine mit deinen Agents 24/7 laufen muss, reicht eine 2–4-GB-[Hetzner-Cloud](https://go.bitdoze.com/hetzner)-Kiste für grob 4–8 EUR/Monat; keine GPU nötig. Ein günstiger [Hostinger-VPS](https://go.bitdoze.com/hostinger-vps) mit NVMe/EPYC-Specs funktioniert auf derselben Stufe. Für das komplette Always-on-Setup inklusive Push-Genehmigungen und den Mosh-Stolperfallen: [Agents 24/7 auf einem VPS laufen lassen und vom Handy steuern](/control-ai-agents-from-phone-moshi-herdr/).

### Fun-Picks (herdr-ohmyzsh, herdr-flock)

Die Fun-Schublade, nicht in den Zehn mitgezählt. `robbyrussell/herdr-ohmyzsh` (84 Stars) stammt vom Oh-My-Zsh-Autor selbst: langsame Befehle in einer Sidebar gelistet, Fertig-Benachrichtigungen und ein Reload von Oh My Zsh über alle Idle-Panes. Wenn du schon die [besten Oh-My-Zsh-Plugins](/de/beste-oh-my-zsh-plugins/) fährst, ist das das Herdr-seitige Gegenstück.

```bash
herdr plugin install robbyrussell/herdr-ohmyzsh
```

`ragamo/herdr-flock` (41 Stars) rendert deine Agents als Pixel-Art-Schafe auf einer Weide. Es ist nutzlos und es ist entzückend – das korrekte Verhältnis für ein Plugin, das nach Schafen benannt ist.

```bash
herdr plugin install ragamo/herdr-flock
```

![herdr-flock: Pixel-Art-Schafe wandern über eine Weide in einem Herdr-Pane, ein Schaf pro Agent](@assets/images/26/10/herdr-flock-sheep.webp)

## Wie du ein Herdr-Plugin in 5 Minuten prüfst

![Prüf-Flussdiagramm für Herdr-Plugins: Repository, Manifest, Befehle, Skripte, Autor-Historie, dann pinnen und installieren, mit Abbruch-Ausgängen an jedem Gate](@assets/images/26/10/herdr-plugin-vetting-flow.webp)

Die Marketplace-Seite selbst sagt: „Listings aren't reviewed by Herdr, so install at your own discretion." Der interaktive Preview-Dialog ist das einzige Gate im ganzen System. Hier ist die Checkliste, die ich durchgehe, bevor dieser Dialog überhaupt erscheint.

**Der Marketplace ist kein Katalog**

  herdr.dev/plugins ist ein automatischer Index. Niemand bei Herdr hat diese Repos gelesen. Fünf Minuten Lesen schlagen einen schlechten Install, und neu prüfen musst du nur, wenn du den Pin bewegst.

1. **Lies `herdr-plugin.toml`.** Jeder `[[build]]`-, `[[startup]]`-, `[[actions]]`-, `[[events]]`- und `[[link_handlers]]`-Eintrag ist Code, der auf deiner Maschine laufen wird. Prüfe die Pflichtfelder (`id`, `name`, `version`, `min_herdr_version`) und lies jedes `command`-Array, bevor du dir irgendetwas anderes ansiehst.
2. **Lies jeden Befehl als argv.** Es gibt keine Shell-Expansion, außer der Befehl startet eine Shell. Quoting-Überraschungen verstecken sich in `["bash", "-c", "..."]`-Wrappern, nicht in `["node", "index.js"]`.
3. **Überflieg die Skripte.** Alles, was `~/.aws`, `~/.ssh`, `.env`-Dateien oder Agent-Credential-Verzeichnisse anfasst, verdient ein volles Lesen, nicht ein Überfliegen. Das ist der Unterschied zwischen einem UI-Plugin und etwas, das deine Tokens exfiltrieren kann.
4. **Prüfe Autor und Repo-Historie.** Stars sind kein Vertrauen, und ein Topic-Tag ist keine Garantie, dass das Ding überhaupt als Herdr-Plugin installiert. Frische Accounts plus obfuskierte Build-Schritte sind ein Weggeh-Grund. Wenn du einen sanften ersten Prüflauf willst: `qu8n/herdr-automatic-rename` und `tdi/herdr-worktree-setup` sind klein und end-to-end lesbar.
5. **Pinne den geprüften Tag.** `herdr plugin install owner/repo --ref vX.Y.Z`. Niemals `--yes` beim ersten Install. Wenn sich das Manifest nach der Vorschau ändert, bricht Herdr ab; lass es abgebrochen und lies nochmal nach.

  

    
- herdr-plugin.toml lesen, inklusive jedes [[startup]]- und [[build]]-Befehls
    
- Befehle als argv-Arrays lesen; Shell-Wrappern misstrauen
    
- Skripte überfliegen, mit voller Aufmerksamkeit auf Credential-Pfaden
    
- Autor-Historie prüfen; weggehen bei frischen Accounts mit obfuskierten Builds
    
- Den geprüften Tag pinnen; niemals blind mit --yes installieren
  

Kostennotiz: Prüfen kostet 5 Minuten einmal pro Plugin. Neuinstallieren aus einem gepinnten Ref ist der Update-Pfad, und neu prüfen heißt nur das Delta zwischen altem und neuem Tag. Für Remote-Relay-Plugins konkret ist das Threat Model dein ganzes Terminal. Wenn du eine Kiste überhaupt exposest: [Einen exponierten Server härten](/bsi-security-report-docker-ufw/) lesen, bevor du ein Relay exposest.

## Herdr-Plugins vs. tmux: was anders ist

Die Frage „Herdr vs. tmux" läuft mehr über Plugins als über Panes. Wenn du nur Panes und Scrollback willst, ist tmux immer noch gut – und wird es in fünf Jahren auch sein.

| Fähigkeit | tmux | Herdr-Plugins |
|---|---|---|
| Plugin-Verteilung | Shell-Skripte ins `.tmux.conf`-Umfeld kopieren | `herdr plugin install owner/repo` aus einem Marketplace-Index |
| Plugin-Definition | Ad-hoc-Shell-Funktionen | `herdr-plugin.toml`-Manifest mit build/startup/actions/events/panes |
| API-Oberfläche | tmux-Befehle | Die komplette herdr-CLI via `HERDR_BIN_PATH` |
| Events | Hooks, die du selbst verdrahtest | Deklarative `[[events]]` wie `on = "worktree.created"` |
| URL-Handling | Manuell | `[[link_handlers]]` mit Rust-Regex, Ctrl-Klick-Dispatch |
| Sandboxing | Keins | Keins |
| Update-Kanal | Was immer das README des Plugins sagt | Keiner in v1, Neuinstall zum Aktualisieren |
| Review-Prozess | Keiner | Keiner – es ist ein automatischer Index |

Was Herdr dir gibt: manifest-deklarierte argv-Befehle, Events, Pane-Platzierung, Link-Handler und Keybinding-Integration in `~/.config/herdr/config.toml`. Was es dir nicht gibt: Sandboxing, verwalteten Storage (dauerhafter State sind die eigenen Dateien des Plugins), einen Update-Kanal oder irgendeinen Review-Prozess. tmux' Plugin-Szene ist kleiner und dümmer – und das ist zugleich ihre Sicherheitsstory.

Mein Urteil: Das Plugin-Ökosystem ist der Grund zu wechseln, wenn du Agent-CLIs fährst, nicht der Multiplexer-Teil. tmux multiplext schon. Herdrs Vorsprung ist, dass Agent-Workflows wie Diff-Review, Session-Graphen und Workspace-Bootstrap einen Befehl entfernt sind statt ein Wochenende Skripte. Wenn dein tmux-Setup ohnehin ein Haufen Custom-Shell ist und du täglich Agents darin fährst, ist die Migration ein Wochenende wert. Wenn du meist zwei Shells und einen Log-Tail laufen lässt, hat tmux weniger bewegliche Teile und nichts zu prüfen. Für den Runtime-Vergleich selbst: [unser Herdr-Review (Open-Source-Agent-Multiplexer)](/herdr-agent-multiplexer/), das die tmux-Frage in der Tiefe behandelt. Und wenn das, was du eigentlich suchst, der Multiplexer selbst ist statt der Agent-Schicht, ist [Superlogical Rex](/de/superlogical-rex/) die neue Terminal-seitige Option, die man verfolgen sollte.

## Stolperfallen, die dir niemand sagt

Das sind die Dinge, die dich im ersten Monat beißen werden.

1. **Kein `plugin update`-Befehl.** Updates heißen, `herdr plugin install` erneut auszuführen – das ersetzt den verwalteten Checkout. Alles in `HERDR_PLUGIN_ROOT` ist weg. Halte Secrets und Einstellungen in `HERDR_PLUGIN_CONFIG_DIR`, und du kannst beliebig neu installieren.
2. **Namenskollisionen sind real.** Es gibt zwei `herdr-auto-title`-Repos (kryptamine 238 Stars vs. sh1ma 51 Stars), zwei `herdr-agent-usage`-Repos (levi-qiao 168 Stars vs. senna-lang 47 Stars) und mindestens drei browser-artige Plugins (`ogulcancelik/herdr-browser` 357 Stars, StructuPath 23 Stars, plus `zenbu-labs/terminal-browser`). Fix: immer vollqualifiziertes `plugin.id.action` verwenden und notieren, welches `owner/repo` du installiert hast.
3. **Fehlende Lizenzen.** `herdr-remote` und `herdr-mobile-relay` zeigen beide NOASSERTION. `pi-extensible-workflows` hat gar kein Lizenzfeld. Baue auf diesen nichts, wofür du bezahlt wirst, ohne eine Lizenz, mit der du leben kannst.
4. **`ui_busy` bei Popups.** Popups sind Singleton-Session-Ressourcen ohne Pane-ID und ohne Pane-Events. Ein Settings- oder Copy-Mode-Modal blockiert sie. Wenn das Popup eines Plugins „nichts tut", schließe zuerst deine Modals.
5. **Keybinding-Kollisionen.** `[[keys.command]]`-Einträge können die eingebaute Keymap überschatten. Wähle unbenutzte Keys und führe `herdr server reload-config` nach jeder Änderung aus – sonst ändert sich nichts und du gibst dem Plugin die Schuld.
6. **Startup-Hooks sind keine Daemons.** `[[startup]]` ist einmalige Initialisierung, die bei Live-Handoff erneut läuft. Ein Plugin, das sie als Supervisor missbraucht, wird sich danebenbenehmen. Wenn du eins schreibst, mach den Hook idempotent.
7. **Build-Fehler brechen den Install ab**, mit gekürztem stdout und stderr. Fast immer eine fehlende Toolchain. Installiere `cargo`/`npm`/`go`, versuch es erneut und lies das gekürzte Log.
8. **0.7.x-API-Fluktuation.** Dieses Ökosystem ist Monate alt. Pinne Refs, erwarte `min_herdr_version`-Bumps und behandle jede Neuinstallation als Gelegenheit, das Manifest-Diff nochmal zu lesen.

**Star-Zahl ist kein Vertrauen**

  Beliebte Plugins kommen trotzdem mit Namenskollisionen, NOASSERTION-Lizenzen und Popup-Eigenheiten. Stars sagen dir, was andere installiert haben, nicht, was sicher in deiner Umgebung läuft. Paare sie mit dem 5-Minuten-Check und gepinnten Refs – und rechne damit, dass sich die 0.7.x-API unter dir bewegt.

## Ein eigenes Plugin in 20 Zeilen schreiben

Das meiste, was Plugins tun, ist: einen Befehl ausführen, ein Pane zeigen, die herdr-CLI zurückrufen. Hier ein minimales Manifest.

```toml
# herdr-plugin.toml
id = "example.workspace-tools"
name = "Workspace Tools"
version = "0.1.0"
min_herdr_version = "0.7.0"
platforms = ["linux", "macos", "windows"]

[[actions]]
id = "list-workspaces"
title = "List workspaces"
contexts = ["workspace"]
command = ["node", "index.js"]
```

Und das Callback-Muster. Die ganze CLI ist die API:

```javascript
// index.js
const { spawnSync } = require("node:child_process");
const herdr = process.env.HERDR_BIN_PATH ?? "herdr";

const res = spawnSync(herdr, ["workspace", "list"], { encoding: "utf8" });
console.log(res.stdout);
```

Lokale Entwicklungsschleife:

```bash
herdr plugin link /abs/path/to/plugin   # register, no build commands run
herdr plugin action invoke example.workspace-tools.list-workspaces
herdr plugin log list --plugin example.workspace-tools --limit 20
herdr plugin unlink example.workspace-tools
```

Wohin State gehört: `HERDR_PLUGIN_CONFIG_DIR` für Einstellungen und Secrets, `HERDR_PLUGIN_STATE_DIR` für dauerhaften State. Es gibt keine verwaltete Storage-API in v1, das Plugin schreibt also eigene Dateien. Und schreibe niemals in `HERDR_PLUGIN_ROOT`; Neuinstall ersetzt es.

Plugins vs. Skills, weil die Leute sie verwechseln: Plugins erweitern die Terminal-Runtime (Panes, Events, Keybindings). Skills erweitern den Kontext des Agents (Anweisungen, die das Modell lädt). Andere Ebene, andere Datei, anderes Problem. Wenn das Problem „der Agent weiß nicht, wie man X macht" ist, ist das ein Skill, und [Agent-Skills im Vergleich](/de/beste-ai-skills-webdesign/) ist die richtige Lektüre.

[Die offiziellen Plugin-Beispiele durchstöbern](https://github.com/ogulcancelik/herdr-plugin-examples)

Herdrs Docs nutzen dieses Cookbook für Install-Beispiele – mit dem Vorbehalt, dass Herdr diese Plugins nicht pflegt. Behandle sie als lesbare Beispiele, nicht als gesegneten Code.

## FAQ: Herdr-Plugins

**Sind Herdr-Plugins sicher zu installieren?**

  Es ist ungeprüfter Code, der als dein User läuft. Herdr validiert das Manifest und sandboxed nichts. Die Gegenmaßnahme ist die 5-Minuten-Prüf-Checkliste (Manifest, Befehle, Skripte, Autor-Historie) plus Installieren mit dem Preview-Dialog und Pinnen des geprüften Tags. Gib niemals `--yes` beim ersten Install. Wenn du das befolgst, ist das Restrisiko normales Open-Source-Risiko statt Blindvertrauen.

**Wie aktualisiere ich Herdr-Plugins?**

  Es gibt kein `herdr plugin update` in Plugin v1. Führe `herdr plugin install owner/repo` erneut aus (optional mit neuem `--ref`), und Herdr ersetzt den verwalteten Checkout. Halte Einstellungen und Secrets in `HERDR_PLUGIN_CONFIG_DIR`, niemals in `HERDR_PLUGIN_ROOT`, und Neuinstallationen werden schmerzlos. Prüfe das Diff neu, wenn du den Pin bewegst.

**Wie viele Plugins gibt es im Herdr-Plugin-Marketplace?**

  Grob 1.000+ indexierte Plugins auf herdr.dev/plugins, gegenüber etwa 1.500 Repositories mit Tag `herdr-plugin` auf GitHub (Topic-Zahl, 2026-10-08). Die rohe Topic-Zahl enthält Dotfiles und mitgetaggte Tools; der kuratierte Index zeigt nur Repos mit parsebaren Manifesten. Beide Zahlen bewegen sich schnell in einem 7 Monate alten Ökosystem – prüfe den Live-Index, wenn du das liest.

**Funktionieren Herdr-Plugins mit Claude Code, Codex und OpenCode?**

  Ja. Plugins steuern, was immer im Pane läuft, und die herdr-CLI ist die API – Agent-Integration ist also kein Sondermodus. Die Top-Picks in diesem Artikel unterstützen explizit Claude Code, Codex, OpenCode und Pi: herdr-reviewr schickt Zeilenkommentare an alle vier, zoetrope grapht Claude-Code- und Codex-Sessions, und collie steuert sie vom Handy. Wenn ein Plugin in seinem README nur einen Agent nennt, ist das meist eine Doku-Entscheidung; entscheidend ist, ob es das Pane und das Transcript liest – und das sagen dir die Manifest-Befehle.

## Das Minimal-Setup

Du brauchst keine zehn Plugins. Drei decken den größten Teil des Werts ab, alles andere ist optional.

  

    
- herdr-reviewr, damit Agent-Code gelesen wird
    
- kryptamine/herdr-auto-title, damit 10 Panes navigierbar bleiben
    
- cloudmanic/herdr-plus, damit sich der Workspace aus einer TOML wieder aufbaut, die dir gehört
  

Installiere diese drei, verifiziere jedes mit `herdr plugin list --json` und `herdr plugin log list` – und hör auf. Füge zoetrope oder herdr-agent-usage hinzu, wenn du Spend oder Session-State aus den Augen verlierst. Überspringe den Zoo. Die Versuchung in einem 1.000-Plugin-Marketplace ist, am ersten Tag alles Glänzende zu installieren und Tag zwei damit zu verbringen, Keybinding-Kollisionen und `ui_busy`-Popups zu debuggen. Drei gut geprüfte Plugins mit gepinnten Refs schlagen zehn, über die du nicht nachdenken kannst.

Ops-Nachwort: All diese Software kostet 0 EUR pro Monat. Wenn Agents 24/7 laufen müssen, reicht ein 2–4-GB-VPS, keine GPU – und dafür lohnt sich [was ein günstiger VPS 2026 kostet](/vps-price-increases/) vor dem Einkauf; ich würde es auf eine [Hetzner-Cloud](https://go.bitdoze.com/hetzner)-Kiste legen. Remote-Zugriff via Free-Tier-Tailscale oder Cloudflare-Tunnel, nicht über offene Inbound-Ports. Sichere `config.toml` plus das Config-Verzeichnis jedes Plugins; Plugin-Code fetcht aus gepinnten Refs neu. Prüfe neu, wenn du einen Pin bewegst. Herdr Cloud ist nur per Warteliste – plane also nicht damit.

[Unser Herdr-Review lesen](/herdr-agent-multiplexer/)