---
title: "Die besten Terminal-Multiplexer 2026: tmux vs Zellij vs Rex vs Herdr vs Tern vs TuiOS vs Muxy"
description: "Praxisvergleich der 7 besten Terminal-Multiplexer 2026: tmux, Zellij, Rex, Herdr, Tern, TuiOS und Muxy – getestet für SSH-Sessions, KI-Coding-Agenten und Remote-Arbeit."
date: 2026-10-29
categories: ["linux"]
tags: ["tmux","herdr","muxy"]
---

Die Terminal-Multiplexer-Frage war früher in fünf Sekunden beantwortet: tmux, außer du warst auf einer Box eingeloggt, die so alt war, dass es nur GNU `screen` gab. Diese Antwort ist etwa Mitte 2026 abgelaufen. [KI-Coding-Agenten](/ai-coding-tools/) haben verändert, wozu ein Multiplexer eigentlich da ist. Eine Shell über eine wackelige SSH-Verbindung am Leben zu halten war früher der ganze Job; heute heißt der Job, sechs Agenten über git worktrees hinweg am Leben zu halten, zu wissen, welcher gerade auf einen Permission-Prompt blockiert ist, und das von einem Laptop oder Handy freizugeben, ohne durch zwanzig Panes zu jagen.

Vier ernsthafte Tools konkurrieren jetzt innerhalb deines Terminal-Emulators (**tmux**, **Zellij**, **Herdr** und **TuiOS**), plus drei weitere (**Superlogical Rex**, **Stencil Tern** und **Muxy**), die argumentieren, der Multiplexer sollte der Terminal-Emulator selbst *sein*.

Ich habe alle sieben an echten Projekten gefahren und über die meisten eigene Deep Dives geschrieben. Dieser Guide stellt das ganze Feld nebeneinander: wie sich die Architekturen unterscheiden, Install- und Config-Snippets zum heute-Abend-Einfügen, wie jedes mit KI-Agent-Flotten, Remote-SSH- und Handy-Workflows umgeht, eine Keybinding-Übersetzungstabelle und wo jedes Tool immer noch wehtut. Jeder Screenshot unten stammt aus meinem eigenen Setup.

Versionen und GitHub-Star-Zahlen wurden am 2026-10-29 verifiziert (Muxy am 2026-11-01): **tmux 3.8** (~49k Stars), **Zellij 0.45.1** (~35.7k Stars), **Herdr 0.9.3** (~44k Stars), **TuiOS 0.11.1** (~5.4k Stars), **Rex** Public-Testing-Build, **Tern 0.9.5** Closed Beta und **Muxy 2.1** (~2.3k Stars).

## Die Kurzversion

Wenn du nur die Empfehlung vor dem Deep Dive willst:

- **tmux**: Nimm es, wenn du dich auf Maschinen einloggst, die du nicht administrierst, ein 1,2-MB-Binary willst, das schon installiert ist, oder ein Jahrzehnt `.tmux.conf`-Muskelgedächtnis hast. Immer noch der richtige Default für normale Server- und Shell-Arbeit.
- **Zellij**: Nimm es, wenn du tmux' Job mit modernen Defaults erledigt haben willst: On-Screen-Key-Hints, KDL-Projekt-Layouts, eingebaute Session-Resurrection, First-Class-Nested-Sessions (v0.45+), WebAssembly-Plugins und einen eingebauten Web-Client.
- **Herdr**: Nimm es, wenn KI-Coding-Agenten das meiste von dem sind, was du fährst. Die Echtzeit-Agent-State-Sidebar (`working` / `blocked` / `done` / `idle`), die Unix-Socket-API und das Mobile-/Web-Client-Ökosystem sind der Grund, warum es existiert.
- **TuiOS**: Nimm es, wenn du einen Tiling-Window-Manager in deinem Terminal willst plus die tiefste eingebaute Agent-Inbox (Prompt-Holds, queued Replies, Inline-Diff-Review mit Notizen, `fan`-Worktree-Runs und einen tmux-Shim) und mit einem schnelllebigen jungen Projekt leben kannst.
- **Rex**: Nimm es, wenn du auf macOS bist und den Multiplexer in die Terminal-App selbst eingebaut willst, powered by `libghostty` vom Ghostty-Schöpfer, mit First-Class-Remote-System-Logins.
- **Tern**: Nimm es, wenn du ein plattformübergreifendes Rust-Terminal willst, in dem Panes auch native Git-Clients, SQLite-Browser, Jupyter-Notebooks, Kanban-Boards und KI-Agent-Blöcke sein können, und dich eine Closed-Beta-Warteliste nicht stört.
- **Muxy**: Nimm es, wenn du den einzigen Open-Source-Eintrag im Terminal-App-Lager willst: eine Rust-+-GPUI-App auf `libghostty` (heute macOS, Linux experimentell), deren Server Panes am Leben hält, 12 KI-Coding-Agenten out of the box erkennt und native iOS-/Android-Companions mitbringt.

## Alle 7 Terminal-Multiplexer auf einen Blick

| Feature | tmux | Zellij | Herdr | TuiOS | Rex | Tern | Muxy |
|---|---|---|---|---|---|---|---|
| **Kategorie** | In-Terminal-Multiplexer | In-Terminal-Multiplexer + Workspace | In-Terminal-KI-Agent-Multiplexer | In-Terminal-Tiling-WM + Agent-Mux | Native Terminal-App + Multiplexer | Native Terminal-App + Dev-Workspace | Native Terminal-App + Agent-bewusster Multiplexer |
| **GitHub Stars (Okt 2026)** | ~49k | ~35.7k | ~44k | ~5.4k | Closed Source | Closed Source | ~2.3k |
| **Sprache & Lizenz** | C, ISC | Rust, MIT | Rust, Apache-2.0 | Go, MIT (Bubble Tea v2) | Closed Source („free forever") | Rust, Closed Source | Rust + GPUI, MIT |
| **Binary / Footprint** | ~1,2 MB Binary, winziges RAM | ~18 MB Binary | ~11 MB Single-Binary | ~16 MB Pure-Go-Binary | Native macOS-App (`libghostty`) | Native Rust-App (~150 ms Launch) | Native App + `muxy`-/`muxy-server`-Binaries |
| **Session-Besitzer** | Hintergrund-Server | Hintergrund-Server | Hintergrund-Session-Server | Hintergrund-Daemon | Server besitzt PTYs, teet rohe Bytes | Daemon besitzt Sessions + Blocks | `muxy-server` besitzt Terminals (lokal + SSH-Hosts) |
| **Reboot-Recovery** | Via Plugin (`tmux-resurrect`) | Eingebautes Layout + Commands, opt-in Scrollback | Layout, Verzeichnisse, Agent-Konversationen, opt-in Screen-History | Layout, Verzeichnisse, Pane-History, Agent-Konversationen | Server-persistente Sessions | Daemon-persistente Sessions + Scrollback | Server-persistente Sessions + gespeicherte Layouts |
| **KI-Agent-Support** | Keiner (Bytes in einem Pane) | Keiner (Bytes in einem Pane) | State-Sidebar, TOML-Manifeste, Hooks, Socket-API | Unified Inbox, Prompt-Holds, Diff-Review, `fan`-Worktrees, MCP | Nichts Spezifisches | Nativer `omp`-Block + Attention-Inbox | Erkennung für 12 Agenten, Benachrichtigungen, Agents-Panel |
| **Layout-Fähigkeiten** | Splits, Fenster, Floating Panes (3.8) | Tiled, Floating, Stacked Panes, Tabs | Splits, Tabs, Spaces, Zoom | BSP / Master-Stack / Scrolling-Tiling, Floating, PiP, 9 Workspaces | Native OS-Tabs, Splits, Fenster | Splits, Tabs, PiP, 4 Layout-Modi + native Blöcke | Splits, Tabs, Per-Projekt-Worktrees, Workspaces, Sidebar-Layouts |
| **Remote-Workflow** | `ssh` rein, dann `tmux attach` | `ssh` rein oder eingebautes `zellij web`-Browser-UI | `ssh`, `herdr --remote` Thin Client, Multi-Machine-Sidebar | Eingebauter SSH-Server, Remote-Panes in lokaler Session, `tuios-web` | Eingebautes Remoting mit echtem OS-Login (`who`) | `tern remote serve` (QUIC), WebGPU-Browser + Mobile-Clients | SSH zu Remote-`muxy-server`, iOS/Android-Companions über LAN/VPN |
| **Config-Format** | `~/.tmux.conf` | KDL (`~/.config/zellij/config.kdl`) | TOML (`~/.config/herdr/`) | TOML (`~/.config/tuios/config.toml`) | Lua (`~/.config/rex/init.lua`) | Settings-UI + Luau-Plugins | Settings-UI + `settings.toml` |
| **Scripting & API** | CLI, `tmux -CC` Control Mode, Hooks, Formate | `zellij action`, `zellij pipe`, WASM-Plugins | CLI, JSON-Unix-Socket-API, ~1.000 Plugins | CLI (`--json`), `.tape`-Skripte, MCP Stdio, Herdr-Socket/-Plugins | `rex`-CLI (`--json`), typisierte Lua-Actions (`rex do`) | `tern`-CLI, Event-Stream, `tern ctl` / `tern shot`, Luau-SDK | `muxy`-CLI (`--json`, `--host`), Extension-API, `agent.status`-Events |
| **Grafik-Support** | Sixel / `allow-passthrough on` | Kitty Graphics + Sixel (v0.45+) | Terminal-Passthrough | Natives Kitty Graphics + 24-bit Color | Natives `libghostty`-Rendering | Nativer Surface-Renderer | Natives `libghostty`-Rendering (GPUI) |
| **Plattformen** | Jedes Unix, Linux, macOS, BSD | Linux, macOS, Windows | Linux, macOS, Windows | Linux, macOS, Windows, FreeBSD, OpenBSD | Jetzt macOS (Linux/Win/iOS/Web in Arbeit) | macOS, Linux, Windows, Android (iOS als Nächstes) | macOS 14+, Ubuntu 24.04 (experimentell); iOS/Android-Companions |
| **Preis & Status** | Kostenlos, v3.8 stable | Kostenlos, v0.45.1 stable | Kostenlos, v0.9.3 pre-1.0 | Kostenlos, v0.11.1 (gestartet Sept 2025) | Kostenlos, Public-Testing-Warteliste | Preise unbekannt, v0.9.5 Closed Beta | Kostenlos + MIT, v2.x stable (+ Beta-Channel) |

## Warum sich die Architektur 2026 spaltet: In-Terminal-TUI vs Terminal-als-Multiplexer

Bevor wir uns einzelne Tools anschauen, hilft es, den strukturellen Split in der Tabelle oben zu verstehen. Jedes Tool hier fällt in eines von zwei Lagern:

1. **In-Terminal-Multiplexer (tmux, Zellij, Herdr, TuiOS)** sitzen *zwischen* deinem Terminal-Emulator und der Shell: `Terminal-App → Multiplexer-Server → PTY → Shell/Agent`. Weil der Multiplexer in jedem Terminal-Fenster läuft, muss er seine eigene interne virtuelle Terminal-Zustandsmaschine pflegen, jede ANSI-Escape-Sequenz vom Programm parsen und dann Diffs an dein äußeres Terminal re-emittieren.
   - **Der Vorteil:** funktioniert über schlichtes SSH auf einem headless $4/Monat-Linux-VPS, funktioniert in Kitty, [Ghostty](/de/ghostty-terminal/), WezTerm, Alacritty oder einem iPhone-SSH-Client und überlebt den Wechsel von Terminal-Apps.
   - **Der Nachteil:** jedes Byte wird zweimal geparst. Wenn der interne Parser des Multiplexers langsamer ist als dein GPU-Terminal oder eine neuere Escape-Sequenz nicht versteht (wie Kitty Graphics, bevor Passthrough landete), wird der Multiplexer zum Bottleneck.

2. **Terminal-als-Multiplexer-Apps (Rex, Tern, Muxy)** eliminieren die Middleman-TUI. Ein Hintergrund-Daemon besitzt die PTYs (lokal oder auf einem Remote-Server), und die Desktop-, Browser- oder Mobile-App ist ein nativer Client, der direkt an diesen Daemon attacht.
   - **Der Vorteil:** null Doppelparsing, natives GPU-Rendering (`libghostty` in Rex und Muxy, Rust + WebGPU in Tern), unabhängiges Scrollback pro attached Client und Panes, die gar keine Text-Raster sein müssen.
   - **Der Nachteil:** du musst ihre Terminal-App (oder ihren Web-/Mobile-Client) nutzen, statt den Multiplexer in dem Terminal-Emulator zu fahren, den du schon hast. Muxy ist die Ausnahme: Es liefert auch eine `muxy`-Terminal-UI, die an denselben Server aus jedem Terminal attacht.

---

## 1. tmux: der Amtsinhaber

![tmux 3.x mit einem Drei-Pane-Layout: git log links, htop oben rechts und eine Dateiliste unten rechts, mit der grünen Statusbar](@assets/images/26/10/multiplexer-tmux.webp)

tmux (~49k Stars, C, ISC) ist ein ~1,2-MB-Binary, das auf jedem Server, auf den du dich je einloggst, entweder vorinstalliert ist oder ein `apt install tmux` entfernt. Ein Hintergrund-Server besitzt deine Sessions, Windows agieren als Tabs, Panes sind Splits innerhalb von Windows, und der `Ctrl+b`-Prefix ist seit 18 Jahren konsistent geblieben.

### Was in tmux 3.7 und 3.8 landete

tmux ist konservativ, nicht tot. Zwei aktuelle Releases modernisierten mehrere raue Kanten:

- **Floating Panes (3.7, vervollständigt in 3.8):** `Ctrl+b *` öffnet einen Overlay-Floating-Pane über deinem aktuellen Fenster, ohne dein Split-Layout zu stören, mit Move/Resize-Bindings unter `Ctrl+b g`.
- **Eingebauter Fuzzy-Switcher (3.8):** `Ctrl+b Tab` öffnet einen Fuzzy-Finder über Sessions und Fenster und ersetzt das externe `fzf`-Popup-Skript nur zum Session-Wechseln.
- **Eingebaute Light/Dark-Themes (3.8):** tmux erkennt jetzt den Hintergrund deines Terminals und wendet out of the box eine eingebaute Theme-Option an.
- **Modus-spezifische Hilfe und Zeilennummern:** `Ctrl+h` im Copy Mode zeigt nur Copy-Mode-Bindings, und `set -g copy-mode-line-numbers on` fügt Zeilennummern für schnellere Selection-Sprünge hinzu.

### Installation und Tagesworkflow

  
### Linux (Debian/Ubuntu/RHEL)

    ```bash
    # Debian / Ubuntu
    sudo apt update && sudo apt install -y tmux

    # RHEL / AlmaLinux / Rocky / Fedora
    sudo dnf install -y tmux
    ```
  

  
### macOS (Homebrew)

    ```bash
    brew install tmux
    tmux -V   # prints tmux 3.8
    ```
  

  
### Essentielle ~/.tmux.conf

    ```tmux
    # Enable mouse clicks, pane resizing, and wheel scroll
    set -g mouse on

    # Start window and pane numbering at 1 instead of 0
    set -g base-index 1
    setw -g pane-base-index 1
    set -g renumber-windows on

    # 24-bit true color and image passthrough (Kitty/Sixel)
    set -g default-terminal "tmux-256color"
    set -as terminal-features ",*:RGB"
    set -g allow-passthrough on

    # Larger scrollback for build and agent logs
    set -g history-limit 50000
    ```
  

Der eine Befehl, der sich auf jedem Server als Alias lohnt, ist **attach-or-create**:

```bash
tmux new -A -s dev
```

Wenn die `dev`-Session schon existiert, attacht `tmux new -A -s dev` sie; wenn nicht, erstellt es sie. Kombiniere es mit `tmux -CC attach -t dev` auf macOS, wenn du iTerm2 nutzt und Remote-tmux-Fenster als native macOS-Tabs gerendert willst.

### Wo tmux 2026 wehtut

Für tmux sind Claude Code, das auf eine destruktive Bash-Freigabe wartet, und `tail -f /var/log/syslog` identisch: Bytes in einem Pane. Es gibt keinen semantischen State, keine Cross-Session-Inbox und keine eingebaute Möglichkeit, Panes von einem Agenten zu orchestrieren, ohne `tmux send-keys` und `tmux capture-pane`-Shell-Skripte zusammenzukleben. Reboot-Persistenz erfordert außerdem Drittanbieter-Plugins (`tmux-resurrect` und `tmux-continuum`) via TPM, und zwei Clients, die am selben Fenster attacht sind, teilen sich weiterhin eine einzige Scroll-Position, außer du erstellst grouped Sessions.

- **Am besten für:** unverwaltete Remote-Server, minimale VPS-Setups, Pair Programming über SSH und alle, die eine Config wollen, die in zehn Jahren noch unverändert funktioniert.
- **Überspringen, wenn:** du auffindbare UI-Controls willst oder fünf KI-Coding-Agenten gleichzeitig beaufsichtigen musst.

Mein [tmux-Grundlagen-Guide](/tmux-basics/) führt durch Installation, Sessions, Windows, Panes, TPM-Plugins und Troubleshooting von Protokollversions-Mismatches nach Upgrades.

---

## 2. Zellij: der freundliche moderne Multiplexer

![Zellij 0.45.1 mit drei Panes (git log links, htop oben rechts, Dateiliste unten rechts) plus den charakteristischen Key-Hint-Bars oben und unten im Bildschirm](@assets/images/26/10/multiplexer-zellij.webp)

Zellij (~35.7k Stars, Rust, MIT) ist, wie ein klassischer Terminal-Multiplexer aussieht, wenn er von Grund auf in Rust designed wurde. Statt jeden Befehl hinter einer unsichtbaren Prefix-Taste zu verstecken, rendert Zellij eine kontextuelle Key-Hint-Bar, die exakt die Tasten zeigt, die in deinem aktuellen Modus verfügbar sind (`NORMAL`, `PANE`, `TAB`, `RESIZE`, `MOVE`, `SEARCH`, `SESSION` oder `LOCK`). Du kannst Zellij einem Entwickler in die Hand geben, der nie einen Multiplexer benutzt hat, und er splitet, floatet und stackt Panes innerhalb von zwei Minuten.

### Was Zellij 0.45.1 hervorhebt

- **First-Class-Nested-Sessions (0.45 / 0.45.1):** Zellij lokal zu fahren und dich per SSH auf einen Remote-Server zu verbinden, der auch Zellij fährt, war früher ein Keybinding-Albtraum. In 0.45.1 unterscheiden Nested Sessions innere und äußere Statusbars und Keybindings automatisch über SSH, ohne manuelles Environment-Variable-Forwarding.
- **Nach Command scrollen:** Statt zeilenweise durch 10.000 Zeilen Compiler-Output zu scrollen, kannst du direkt zwischen Shell-Command-Blöcken springen.
- **Reproduzierbare KDL-Layouts & Session-Resurrection:** Layouts leben in sauberen `.kdl`-Dateien. Wenn eine Maschine rebootet oder eine Session endet, serialisiert Zellij dein Layout und deine Pane-Commands auf Disk; ein Reattach stellt den exakten Workspace wieder her und legt gefährliche Commands hinter ein „Press ENTER to run"-Safety-Gate.
- **WebAssembly-Plugin-System:** Plugins kompilieren zu `wasm32-wasip1`, das heißt, du kannst Plugins in Rust, Go, Zig oder C/C++ schreiben und sie in einer Capability-Sandbox-Runtime laufen lassen, statt Shell-Skripten vollen Zugriff auf deinen User-Account zu geben.
- **Eingebauter Browser-Client (`zellij web`):** serviert deine Terminal-Sessions über HTTP/HTTPS mit generierten Login-Tokens und Read-Only-Spectator-Tokens – der einzige klassische Multiplexer mit einem First-Party-Webserver im Hauptbinary.

### Installation, KDL-Layout und Tagescommands

  
### Install & Quick Start

    ```bash
    # macOS or Linux (Homebrew)
    brew install zellij

    # Rust cargo (any platform)
    cargo install --locked zellij

    # Quick launch without installing (Linux/macOS)
    bash <(curl -L https://zellij.dev/launch)

    # Start or reattach
    zellij -s work                        # new named session
    zellij attach -c work                 # attach if exists, create if not
    zellij attach -c monitor -- htop      # start session running htop directly
    zellij web                            # start built-in browser server
    ```
  

  
### Projekt-Layout (~/.config/zellij/layouts/dev.kdl)

    ```kdl
    layout {
        default_tab_template {
            pane size=1 borderless=true {
                plugin location="zellij:tab-bar"
            }
            children
            pane size=2 borderless=true {
                plugin location="zellij:status-bar"
            }
        }
        tab name="code" focus=true {
            pane split_direction="vertical" {
                pane name="editor" size="60%" command="nvim"
                pane split_direction="horizontal" size="40%" {
                    pane name="agent" command="claude"
                    pane name="tests"
                }
            }
        }
    }
    ```
  

Starte das Layout überall mit `zellij --layout dev` (oder `zellij -n dev`, um eine frische Session zu erzwingen).

**Zellij-Keybinding-Konflikte mit Neovim / Emacs fixen**

Default bindet Zellij `Ctrl+p` (Pane), `Ctrl+t` (Tab), `Ctrl+n` (Resize) und `Ctrl+o` (Session), was mit gängigen Vim/Neovim- und Shell-Shortcuts kollidiert. Drück entweder `Ctrl+g` für den **Lock Mode**, oder schalte Zellij auf sein **Unlock-First (non-colliding)**-Preset in `zellij setup`, damit `Ctrl+g` die Multiplexer-Modi nur dann entsperrt, wenn du sie anforderst.

### Wo Zellij zu kurz kommt

Zellij hat denselben blinden Fleck wie tmux bei KI-Agenten: Ein Pane, auf dem Claude Code oder Codex läuft, ist nur ein ANSI-Text-Buffer. Du kannst Panes mit `zellij action` und `zellij run` scripten, und Community-WASM-Plugins beginnen mit Agent-Helpers zu experimentieren, aber es gibt keinen eingebauten Agent-State-Detektor oder Approval-Inbox.

- **Am besten für:** Entwickler, die einen Batteries-included-tmux-Ersatz mit Floating/Stacked Panes, KDL-Projekt-Layouts und einem eingebauten Web-Client wollen.
- **Überspringen, wenn:** du Zero-Config-KI-Agent-State-Tracking über lokale und Remote-Hosts brauchst.

---

## 3. Herdr: die KI-Agent-Control-Plane

![Herdr 0.9 mit der Spaces-Sidebar links, die die Session- und Agent-Gruppen auflistet, und drei Panes mit git log, htop und einer Dateiliste](@assets/images/26/10/multiplexer-herdr.webp)

Herdr (~44k Stars, Rust, Apache-2.0) war der erste Multiplexer, der spezifisch um das Multi-Agent-Bottleneck gebaut wurde: Wenn du acht Coding-Agenten über drei Repositories verteilt laufen hast – welcher hängt gerade wartend auf deine Eingabe?

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

Herdr läuft in deinem bestehenden Terminal-Emulator als einzelnes ~11-MB-Rust-Binary (`herdr`). Ein Hintergrund-Session-Server besitzt die PTYs, damit Sessions SSH-Abbrüche und Laptop-Sleep überleben wie bei tmux, während die TUI eine linke **Spaces-&-Agents-Sidebar** ergänzt, die Echtzeit-Semantic-States für jeden Pane aufrollt: `working`, `blocked`, `done`, `idle` oder `unknown`.

### Wie Herdr Agenten erkennt und orchestriert

Herdr kombiniert out of the box zwei Erkennungsebenen für 14+ Coding-Agenten (Claude Code, Codex, Copilot CLI, Cursor Agent, OpenCode, Gemini CLI, Pi, Amp, Droid, Grok CLI, [Hermes Agent](/hermes-agent-setup-guide/), Antigravity CLI, Kimi Code und QoderCLI):

1. **Zero-Config-TOML-Screen-Manifeste:** Herdr inspiziert den Child-Prozess-Baum und matcht den Live-Bottom-Buffer jedes Panes gegen Per-Agent-Screen-Regeln, um Spinner, Permission-Prompts und Idle-Prompts zu erkennen, ohne die Agent-Config anzufassen.
2. **Lifecycle-Hooks (`herdr integration`):** Die Installation der optionalen Integration verdrahtet das native Hook-System des Agenten (wie Claude Codes `SessionStart`-, `PreToolUse`- und `Stop`-Hooks) für exaktes, latenzfreies State-Reporting.

Unter der TUI sitzt eine JSON-Unix-Socket-API (`~/.config/herdr/herdr.sock`) und CLI, die es einem Lead-Agenten erlaubt, Worker-Panes zu spawnen, Prompts zu übergeben, Sibling-Terminal-Output zu lesen und zu blockieren, bis ein Worker `done` oder `blocked` erreicht:

```bash
# Install Herdr on Linux or macOS
curl -fsSL https://herdr.dev/install.sh | sh    # or: brew install herdr

# Optional: install exact lifecycle hooks
herdr integration install claude
herdr integration install codex
herdr integration install copilot

# Orchestrate panes and agents from scripts or a lead agent
herdr pane list                                 # JSON list of panes and states
herdr pane split --direction right --focus      # split current pane
herdr agent start reviewer --kind claude        # launch tracked agent in pane
herdr pane run <pane-id> "cargo test"           # run command in target pane
```

### Multi-Machine-Windows und das Client-Ökosystem

Seit v0.9 unterstützt Herdr **Multi-Machine-Windows**: `herdr machine add user@vps` oder `herdr --remote user@vps` lässt dich lokale Panes und Remote-VPS-Sessions in einer einzigen Sidebar sehen, plus eingebautes git-worktree-Management und automatisches Agent-Conversation-Resume nach einem Host-Neustart.

Weil Herdr jede UI nur als Client an seinem Socket behandelt, ist ein ganzes Drittanbieter-Ökosystem darum gewachsen:

- **Mobile Kontrolle:** [Moshi](/control-ai-agents-from-phone-moshi-herdr/) (iOS/Android mit Mosh-Transport und `moshi-hook`-Lock-Screen-Push-Freigaben) und Heeler.
- **Browser- & Desktop-Clients:** ColliePWA, `devswha/herdr-web-ui`, `herdrm` (natives macOS), Herdr UI und Moshi Desktop.
- **Plugin-Marktplatz:** ~1.000 indexierte Plugins (`herdr-plugin.toml`), allerdings laufen Plugins unsandboxed als dein OS-User – installiere Marktplatz-Plugins also nie, ohne vorher ihren Source zu lesen.

Lies unser volles [Herdr-Review](/herdr-agent-multiplexer/), den [Herdr-Clients-Vergleich](/best-herdr-clients/) und den Guide zu den [besten Herdr-Plugins](/de/beste-herdr-plugins/) für gehärtete VPS- und Tailscale-Setups.

- **Am besten für:** 3 bis 15 KI-Coding-Agenten über lokale Maschinen und headless VPS-Boxen fahren, mit Lock-Screen-Handy-Freigaben und einem bewährten Ökosystem.
- **Überspringen, wenn:** du Floating Panes oder Tiling-Window-Manager-Layouts willst (Herdrs Layout-Modell ist strikt Splits, Tabs, Spaces und Zoom).

---

## 4. TuiOS: der Tiling-Window-Manager + tiefste Agent-Inbox

![TuiOS 0.11.1 mit drei getilten Fenstern (git log links, htop oben rechts, Dateiliste unten rechts) plus der Dock-Bar oben und dem Session-Rail rechts, der Sessions, Terminals und Dateien auflistet](@assets/images/26/10/multiplexer-tuios.webp)

TuiOS (~5.4k Stars, Go, MIT) steht für *Terminal UI Operating System* und ist der kühnste neue In-Terminal-Multiplexer des Jahres. Gebaut auf Charms Bubble Tea v2 und Lipgloss v2 mit einem Hintergrund-Daemon, kombiniert es zwei Ideen, die normalerweise in getrennten Tools leben: einen Desktop-artigen **Tiling-Window-Manager** (BSP-, Master-Stack- und niri-artige Scrolling-Layouts, Floating Windows, Picture-in-Picture, 9 Workspaces pro Session, Top/Bottom-Dock-Bar mit Live-CPU/RAM-Graphen und ein rechtes Session-/Datei-/Agent-Rail) und eine **Agent-Orchestrierungs-Engine**, die sogar tiefer geht als Herdrs.

### Die Inbox, Prompt-Holds und Worktree-Fan-out

Wo Herdr dir eine Status-Sidebar gibt, baut TuiOS den gesamten Human-in-the-Loop-Workflow in seinen Daemon:

1. **Die Unified Inbox (`Ctrl+b i` oder `tuios list-attention`):** sammelt jede blockierte Freigabe, Frage (`tuios ask-human`), Plan-Review (`ExitPlanMode`), Fehler und ungelesenen fertigen Turn über jede Session auf deiner Maschine und verlinkten Remote-Hosts.
   - Wenn du `[agents.approvals]` aktivierst, fängt TuiOS einzeilige Permission-Requests ab (`PermissionRequest` in Claude Code/Qwen, `permission.asked` in OpenCode/Kilo) und hält sie in der Inbox. Drück `1` (einmal erlauben), `2` (immer) oder `3` (ablehnen) direkt aus der Inbox, ohne Workspaces zu wechseln.
   - Commands, die **Risk Rules** matchen (`rm -rf`, Force-Pushes, `curl | sh` oder Schreibzugriffe außerhalb des Projekt-Roots des Panes), werden mit einem `risk`-Badge markiert und erfordern eine zweite Bestätigung.
2. **Queued Replies und verifizierte Human-Mail:** Wenn ein Agent mitten im Turn beschäftigt ist, hält `tuios queue -w worker "run the migration tests next"` deinen Prompt fest und tippt ihn automatisch, sobald der Agent zur Ruhe kommt. Agenten können sich auch gegenseitig strukturierte Mail schicken (`tuios send-agent-message`, `tuios ask-agent`) oder an `human`, mit kryptografischem `"verified_human": true`-Tagging, damit ein Agent einem anderen Pane keine Human-Freigabe vortäuschen kann.
3. **Git-Worktree-Fan-out, Verifikation und Inline-Diff-Review:** Du kannst mehrere Agenten (sogar über verschiedene Modelle) auf dieselbe Aufgabe in isolierten git worktrees rasen lassen, eine Test-Suite über alle laufen lassen, ihre Diffs mit Zeilennotizen reviewen und den Gewinner shippen:

```bash
# Install TuiOS (macOS / Linux)
brew install tuios
# or release script:
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash

# Fan a prompt across 3 isolated git worktrees using Claude, Codex, and Gemini
tuios fan 3 --agent 'claude,codex --model o5,gemini' 'Add exponential backoff to the HTTP client.'

# Compare line changes and run your test suite across every attempt
tuios fan compare api-fan-add-exponential-backoff
tuios fan verify api-fan-add-exponential-backoff -- go test ./...

# Review an attempt's diff, attach line notes, and send them back to the agent
tuios review api-fan-add-exponential-backoff-2
tuios review note -s api-fan-add-exponential-backoff-2 client/retry.go:42 'log the attempt count here'
tuios review send -s api-fan-add-exponential-backoff-2

# Keep the winning worktree, squash-merge, or open a PR
tuios fan keep api-fan-add-exponential-backoff-2 --merge --squash
```

### Herdr-Socket-Kompatibilität, MCP-Server und der tmux-Shim

Die klügste Engineering-Entscheidung in TuiOS ist, dass es sich weigert, sich von bestehenden Ökosystemen abzuschotten:

- **Herdr-Socket- & Plugin-Bridge:** Jeder TuiOS-Pane exportiert `HERDR_SOCKET_PATH`, `HERDR_PANE_ID` und `HERDR_BIN_PATH`. TuiOS beantwortet 77 von Herdrs 102 Socket-Methoden nativ und führt aktivierte Herdr-Plugins (`terminal-browser`, `herdr-nvim`, `herdr-sidebar`) hinter einem expliziten Per-Pane-Capability-Grant-System (`read`, `write`, `respond`, `fan`, `admin`) aus.
- **Der tmux-Shim (`tuios tmux-shim`):** Tools, die `tmux`-Calls hardcoden (am bekanntesten Claude Codes experimentelle Agent-Teams mit `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` und `fzf --tmux`), funktionieren in TuiOS, ohne tmux zu installieren:
  ```bash
  tuios tmux-shim -- env CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 claude
  ```
  Jeder gespawnte Teammate öffnet sich als natives TuiOS-Fenster mit eigenem Status auf dem Rail und in der Inbox.
- **Nativer MCP-Server (`tuios mcp`) und headless ACP:** `tuios mcp` exponiert TuiOS über Stdio an jeden MCP-fähigen Agenten, und `tuios start-agent --protocol acp 'opencode acp'` kann Agenten headless über das Agent Client Protocol fahren.
- **Remote-Panes & Mobile:** enthält einen eingebauten SSH-Server (`tuios ssh --port 2222`), Remote-Windows auf einem anderen Host, die in deiner lokalen Session gerendert werden (`tuios new-window -s work deploy --host build`), SHA-256-verifizierte Cross-Host-Dateikopien (`tuios cp`), `tuios-web`, QR-Phone-Pairing (`tuios pair`) und ntfy/Pushover-Inbox-Push-Benachrichtigungen.

### Wo TuiOS wehtut

Alter und Oberfläche. Der erste Commit landete im September 2025, und bei v0.11.1 hat es eine massive Command-Oberfläche (`tuios --help` listet über 90 Subcommands). Es shipped schnell, was gelegentliche Breaking Changes zwischen Minor-Releases und eine steilere Lernkurve bedeutet, wenn du jedes Feature auf einmal anmachst. (Du kannst `[agents] enabled = false` in `~/.config/tuios/config.toml` setzen, wenn du nur den Tiling-Multiplexer willst.)

- **Am besten für:** Power-User, die i3/Hyprland-artiges Terminal-Tiling, Multi-Agent-Worktree-Fan-out und eine Inbox wollen, die Prompt-Freigaben und Diff-Reviews nativ handhabt.
- **Überspringen, wenn:** du ein minimales, langsam bewegliches Tool mit kleiner CLI-Oberfläche willst.

---

## 5. Rex: das Terminal, das der Multiplexer ist

![Die Rex-macOS-App mit Session-Tabs oben und gesplitteten Panes mit einem Code-Review, einem git diff und einem Spiel](@assets/images/26/10/superlogical-rex-ui.webp)

Rex ist Mitchell Hashimotos (HashiCorp, [Ghostty](/de/ghostty-terminal/)) Antwort auf ein Problem, auf das er beim Bauen von Ghostty stieß: Moderne GPU-Terminals wie Ghostty, Kitty und Alacritty können Terminal-I/O bis zu 100x schneller parsen als die internen Terminal-Emulatoren in tmux oder screen. Einen traditionellen Multiplexer vor ein schnelles Terminal zu setzen, bremst die ganze Pipeline auf den Parser des Multiplexers aus.

Also dreht Rex die Architektur um. Du fährst `rex` nicht in einem anderen Terminal; Rex *ist* die Terminal-Anwendung.

Video: [Superlogical Rex: Ghostty's Creator Rethinks the Terminal Multiplexer](https://www.youtube.com/embed/2UNVvp-Xebw)

### Wie Rex' Raw-Byte-Streaming funktioniert

1. **Der Server besitzt die PTYs.** Wenn ein Rex-Client sich verbindet, pausiert der Server kurz die PTY-Verarbeitung, sendet einen kompakten binären Handshake-Frame (Dimensionen, Cursor, aktueller Screen-State) und entsperrt sofort die Eingabe.
2. **Rohe PTY-Bytes, keine Screen-Diffs.** Statt Output in ein geteiltes virtuelles Grid zu parsen und Screen-Diffs zu senden, teet der Rex-Server rohe PTY-Byte-Streams an jeden attached Client, genau wie SSH. Jeder Client führt seine eigene eingebettete `libghostty`-Engine aus und parst mit nativer Geschwindigkeit.
3. **Unabhängiges Client-Scrollback.** History backfillt im Hintergrund (neueste Chunks zuerst), und weil jeder Client seinen eigenen Viewport besitzt, können zwei Leute, die an derselben Session attacht sind, unabhängig hochscrollen und Logs inspizieren, ohne sich gegenseitig den Screen zu entreißen.

### First-Class-Remote-Logins und Lua-Automation

Eine Remote-Maschine aus Rex' Command Palette hinzuzufügen öffnet nicht nur eine SSH-Pipe in einem lokalen Pane; es führt einen **echten OS-Login** auf dem Remote-Rex-Server durch (die Session erscheint in `who`, lädt deine Login-Shell, honoriert PAM/User-Limits und authentifiziert über deine bestehenden SSH-Keys oder Tailscale-Identität, inspizierbar via `rex whoami`) mit Mosh-inspirierter Responsiveness.

Jedes Rex-Terminal bekommt automatisch `rex` auf `PATH` plus `REX_SESSION`-, `REX_BLOCK`- und `REX_SERVER`-Environment-Variablen:

  
### Rex CLI Automation

    ```sh
    rex ls                              # list sessions (supports --json)
    rex session inspect                 # inspect current session details
    rex split                           # split current block
    rex send -s build -w 2 'make test'  # send command to window 2 of "build"
    rex capture -b logs                 # print current screen of block "logs"
    rex -S studio ls                    # list sessions on remote host "studio"
    ```
  

  
### Lua-Config (~/.config/rex/init.lua)

    ```lua
    -- Keybindings (supports tmux-style prefix chords too)
    rex.bind("cmd+d", "pane.split", { direction = "right" })
    rex.bind("ctrl+b>c", "window.new")

    -- Custom typed action runnable from palette, keybind, or `rex do`
    rex.action{
      name  = "scratch",
      title = "Open Scratch Window",
      run   = function(ctx, args)
        rex.session.new_window{
          layout = rex.layout.block{
            flavor = "com.superlogical.terminal.shell",
          },
        }
      end,
    }
    rex.bind("shift+cmd+n", "scratch")
    ```
  

### Wo Rex wehtut

Erstens **Plattform-Reichweite**: Nur der macOS-Client ist gerade im öffentlichen Test (Linux-, Windows-, iOS- und Browser-Clients existieren intern bei Superlogical, sind aber noch nicht an externe Tester gegangen). Zweitens **Layout-Modell**: Weil jeder Split eine unabhängige PTY-Verbindung ist, die in einem nativen Container gerendert wird (so wird Rex sich sauber auf iOS und Web anpassen), gibt es keinen verschachtelten In-Window-tmux-Pane-Baum. Drittens ist Rex Closed Source, wenngleich Superlogical verspricht, dass der Rex-Client und -Server „kostenlos ist und immer sein wird", keinen Account erfordert und vollständig self-hostbar ist.

Wenn du auf macOS bist und ein `libghostty`-basiertes Terminal mit einer Automations-CLI willst, die schon ohne Warteliste allgemein verfügbar ist, schau dir [cmux](/cmux-terminal/) an. Für den vollen Deep Dive in Rex' Datenpfad und Exit-Codes, lies mein [Superlogical-Rex-Briefing](/de/superlogical-rex/).

- **Am besten für:** macOS-Entwickler, die native `libghostty`-Geschwindigkeit, persistente lokale/Remote-Sessions und Lua/CLI-Scriptbarkeit ohne TUI-Wrapper wollen.
- **Überspringen, wenn:** du heute Linux- oder Windows-Desktop-Clients brauchst oder eingebaute KI-Agent-State-Überwachung willst.

---

## 6. Tern: das Terminal, das deinen ganzen Workflow will

![Terns Workspace: Ein git-bewusster Files-Pane verfolgt das Projekt links neben einer Shell mit git log](@assets/images/26/10/tern-workspace.webp)

Tern (gebaut von Stencil, dem Team hinter der `omp`-Coding-Agent-CLI) startet mit derselben Prämisse wie Rex (ein Hintergrund-Daemon `tern daemon` besitzt persistente Sessions, während Fenster wegwerfbare Ansichten sind) und schiebt sie in volles Workspace-Territorium. Sich selbst „ein Neoterminal für Electron-Müde" nennend, ist Tern eine native Rust-Anwendung (~150 ms Kaltstart bis zum bereiten Prompt), in der eine Terminal-Shell nur eine Art von **Block** ist.

Video: [Tern hands-on: workspace tour and an agent-built Astro site](https://www.youtube.com/embed/G6F1ASwMEUU)

### Native Blöcke über das Tern Surface Protocol

Statt Chromium einzubetten, rendert Tern strukturierte Tools nativ über sein **Tern Surface Protocol** direkt neben deinen Shell-Splits (oder herausgelöst als Always-on-Top-Picture-in-Picture-Fenster):

- **Git-Block (`⌥⌘G`):** Commit-Graph mit Branch-/Tag-Lanes, staged/unstaged Working Tree mit Line-Staging und Context-Folding, `git peek`, Stashes/Worktrees/Submodules-Ansicht und KI-Commit-Message-Generierung.
- **SQLite-Datenbank-Block:** Schema-Browser, filterbares Daten-Grid mit Inline-Zell-Editoren (Text, JSON, Hex, Bild), SQL-Query-Tabs mit Completion und Ergebnis-Plotting sowie gestaged „Write Changes" / Revert.
- **Kanban-Board-Block (`⌥⌘K`):** verwandelt eine schlichte `TODO.md`-Datei in deinem Repo in ein Drag-and-Drop-Todo/Doing/Done-Board, das sowohl du als auch deine KI-Coding-Agenten lesen und aktualisieren können.
- **Jupyter-Notebook-Block:** führt Code- und Markdown-Zellen direkt gegen deinen lokalen Python-Kernel mit einem Variablen-Inspektor aus – kein Jupyter-Server nötig.
- **Files-, Editor- & Media-Block (`⌘O` / `tern open`):** Syntax-highlighted Code-Editor mit git-Gutter-Diffs, gerendertem Markdown-Toggle, SVG/PDF/Image-Viewern und Video-Frame-Strip-Previews (`EDITOR='tern open --wait'` funktioniert für `git commit`).
- **Browser- (`⇧⌘B`), Task-Manager- und Canvas-Blöcke:** ein inspizierbarer Browser-Block, den Agenten steuern und snapshotten können, ein CPU/RAM/GPU-Prozessbaum und eine freie Zeichen-Canvas.

### Native `omp`-Agent-Blöcke, QUIC-Remoting und CLI-Kontrolle

Weil Stencil `omp` baut, rendert das Starten eines Agent-Blocks eine native UI mit Model-Picker, Thinking-Toggle, Subagent-Task-Tree und einer 1M-Token-Kontext-Budget-Aufschlüsselung (System-Prompt, Tools, Skills, Messages), während Completion-Alerts und Bell-Events in Terns **„Needs attention"-Inbox** geroutet werden. Standard-CLI-Agenten (Claude Code, Codex, Devin) laufen in normalen Terminal-Panes, und ein Community-**Luau-Plugin für Herdr** lässt dich Herdr-Panes in Tern einbetten.

```sh
# Tern workspace & automation CLI
tern ls                              # list sessions, tabs, and panes
tern new | split | move | pip | dock # manipulate window layout from scripts
tern run 'make test'                 # execute command in a pane
tern send / capture / wait           # type into, read back, or block on panes
tern events --filter pane_spawned    # stream live daemon events
tern whoami --json                   # inspect user + host identity chain

# Remote hosts, browser client, and headless screenshot harness
tern remote serve                    # expose session daemon over QUIC
tern web serve                       # serve Wasm + WebGPU client in a browser tab
tern shot scenario.kdl               # render offscreen UI captures
```

Anders als Rex shipped Tern bereits Builds für **macOS, Linux, Windows und Android** (per QR-Code aus der Hosts-Palette gekoppelt, iOS als Nächstes), plus einen WebAssembly-+-WebGPU-Browser-Client (`tern web serve`).

### Wo Tern wehtut

Tern ist **Closed Source**, aktuell in **geschlossener Beta** hinter einer Warteliste (meine hat sich in etwa zwei Tagen geklärt), und Stencil hat noch keine finalen Preise oder kommerziellen Tiers angekündigt. Für eine volle Tour durch jeden Block, siehe mein [Tern-Terminal-Praxisreview](/de/tern-terminal/).

- **Am besten für:** Entwickler, die Daemon-persistente Sessions, QUIC-Remote-Hosts und native Git/SQLite/Kanban/Notebook-Panes ohne Electron-Overhead wollen.
- **Überspringen, wenn:** du nur Open-Source-Terminal-Tools adoptierst oder ein leichtes Unix-Utility willst, das eine Sache tut.

---

## 7. Muxy: die Open-Source-Terminal-App, die deine Agenten beobachtet

![Die Muxy-macOS-App mit der Projekt-Sidebar, die Projekte und git worktrees listet, einer Claude-Code-Session im Haupt-Pane und dem Source-Control-Panel, das 80 geänderte Dateien rechts reviewt](@assets/images/26/10/multiplexer-muxy.webp)

Muxy (~2.3k Stars, Rust + GPUI, MIT) ist der neueste Eintrag im Terminal-als-Multiplexer-Lager und der einzige Open-Source. Wie Rex rendert es Panes über `libghostty`; wie Tern besitzt ein Hintergrund-Server (`muxy-server`) die PTYs, damit Sessions das Schließen des Fensters, das Beenden der App oder einen SSH-Abbruch überleben. Was es abhebt, ist, dass es die beste Idee der Agent-Multiplexer borgt: Muxy erkennt ein Dutzend Coding-Agenten (Claude Code, Codex, Copilot, Cursor, OpenCode, Antigravity, Pi und mehr) aus der Prozessliste und dem, was auf dem Screen ist, und markiert jeden als `working`, `waiting` oder `idle` – ohne Hooks oder Per-Agent-Config.

### Projekte, Worktrees und Remote-Server in einer Sidebar

Alles in Muxy hängt an der Projekt-Sidebar: Jedes Projekt bekommt einen Eintrag, seine eigenen git worktrees (in der App erstellt oder aus welchen übernommen, die du schon gemacht hast) und seinen eigenen Baum von Splits und Tabs. Ein Agents-Panel (`Cmd+Opt+A`) rollt jeden Agenten als „needs input", „working", „completed" oder „idle" auf, und die App sendet eine macOS-Benachrichtigung, wenn einer Aufmerksamkeit braucht; ein Klick springt direkt zum Pane. Remote-Maschinen gesellen sich in dieselbe Sidebar. Muxy spricht über SSH mit einem `muxy-server` auf dem anderen Host (es bietet an, ihn für dich zu installieren), und Remote-Terminals laufen nach dem Disconnect weiter, exakt wie lokale.

### Composer, Extensions und eine echte CLI

- **Composer (Rich Input):** lange Prompts mit angehängten Dateien und Bildern entwerfen, dann an den aktiven Pane senden oder an jeden Split in einem Tab broadcasten. Drafts speichern pro Projekt.
- **Extension Store und API:** Ein dokumentiertes Manifest und eine API (Panels, Bar-Items, Commands, `agent.status`-Events) treiben das eingebaute Git-Source-Control-Panel, den File-Tree und den Editor an. Jeder kann Extensions veröffentlichen.
- **`muxy`-CLI und eine TUI:** `muxy` und `muxy-server` installieren ohne die Desktop-App, was Muxy zum einzigen Tool hier macht, das in beiden Lagern funktioniert. `muxy` auf einer headless Box auszuführen öffnet eine Terminal-UI, die an denselben Server attacht, und `muxy --host devbox` oder `muxy activity list --json` steuert Remote-Server und Agent-States aus Skripten.
- **Mobile Companions:** Die iOS- und Android-Apps verbinden sich mit deinem eigenen `muxy-server` über LAN oder VPN, um Agenten zu beobachten und ihre Prompts zu beantworten. Sessions berühren nie eine Third-Party-Cloud.

```bash
# macOS desktop app
brew install --cask muxy-app/tap/muxy

# Headless CLI + server (what a remote host needs)
brew install muxy-app/tap/muxy-cli
muxy --host devbox              # drive a remote muxy-server over SSH
muxy activity list --json       # agent states and unread alerts
```

### Wo Muxy wehtut

Reichweite und Tiefe. Der polierte Client ist die macOS-App (macOS 14+); Linux-Builds sind experimentell (Ubuntu 24.04 mit Vulkan und WebKitGTK), und es gibt gar keinen Windows-Client. Agent-Support ist Erkennung plus Benachrichtigungen: Es gibt keine Approval-haltende Inbox wie die von TuiOS, keine Risk Rules und keine Lock-Screen-Approve/Deny wie bei Herdr + Moshi. Der Extension Store ist jung, und die ~2.3k Stars zeigen, wie neu die 2.x-Linie ist.

- **Am besten für:** macOS-Entwickler, die ein Open-Source-`libghostty`-Terminal mit persistenten lokalen und Remote-Sessions, Projekt-Worktrees, Agent-State-Benachrichtigungen und nativen iOS/Android-Companions wollen.
- **Überspringen, wenn:** du auf Windows oder Nicht-Ubuntu-Linux bist oder Approval-Queues und Guardrails statt Alerts willst.

---

## KI-Coding-Agent-Orchestrierung im Vergleich

Weil KI-Coding-Agenten der Hauptgrund sind, warum Entwickler 2026 ihren Multiplexer überdenken, hier der Vergleich der sieben Tools speziell bei Agent-Workflows:

| Agent-Fähigkeit | tmux | Zellij | Rex | Tern | Herdr | TuiOS | Muxy |
|---|---|---|---|---|---|---|---|
| **Auto-State-Erkennung (`working`/`blocked`/`done`)** | Nein | Nein | Nein | `omp` nativ; andere via Bell/Exit | **Ja** (14+ Agenten via Manifeste + Hooks) | **Ja** (Manifeste + Hooks + `OSC 7501`) | **Ja** (12 Agenten via Prozess- + Screen-Erkennung) |
| **Cross-Session-Approval-Inbox** | Nein | Nein | Nein | Attention-Inbox (Benachrichtigungen) | Sidebar + Mobile/Web-Client-Inboxen | **Eingebaute Inbox** (`Ctrl+b i`, hält Prompts & Pläne) | Agents-Panel + Benachrichtigungen (keine Prompt-Holds) |
| **Guardrails für risky Commands** | Nein | Resurrection-Enter-Gate | Nein | Agent-abhängig | Agent-abhängig | **Ja** (`risk`-Regeln verlangen Doppel-Press) | Agent-abhängig |
| **Nächsten Prompt queuen, während Agent arbeitet** | Nein | Nein | Nein | Nein | Via Plugins / Skripte | **Eingebaut** (`tuios queue`) | Composer-Drafts (manuell senden/broadcasten) |
| **Agent-zu-Agent-Messaging / Orchestrierung** | Manuelles `send-keys` | Manuelles `zellij action` | `rex send` / `capture` | `tern send` / `capture` + Subagenten | **Unix-Socket-API** + CLI | **Eingebaut** (`ask-agent`, `send-agent-message`, `mcp`) | Composer-Broadcast + `muxy`-CLI |
| **Git-Worktree-Fan-out & Test-Verifikation** | Manuell | Manuell | Manuell | Git-Block-Worktrees | Eingebaute Worktree-Sessions | **Eingebaut** (`tuios fan`, `fan compare`, `fan verify`, `ship`) | Per-Projekt-Worktrees (kein fan/compare) |
| **Inline-Diff-Review mit Notizen an den Agenten** | Nein | Nein | Nein | Git-Block-Diffs | Via Plugins / Clients | **Eingebaut** (`tuios review`, `Ctrl+b v`) | Source-Control-Panel-Diffs (keine Notizen an den Agenten) |

**Herdr vs TuiOS: welchen Agent-Multiplexer solltest du wählen?**

Wenn KI-Coding-Agenten den Großteil deiner Terminal-Zeit ausmachen, ist deine echte Wahl **Herdr vs TuiOS**. Nimm **Herdr** für bewährte Stabilität (~44k Stars) und das beste Mobile-/Desktop-Client-Ökosystem (besonders [Moshi auf iPhone/Android](/control-ai-agents-from-phone-moshi-herdr/)). Nimm **TuiOS**, wenn du Tiling-Window-Management, eingebautes Worktree-Fan-out (`tuios fan`), Inline-Diff-Review mit Notizen (`tuios review`) und Claude-Code-Team-Kompatibilität via `tuios tmux-shim` willst – während du weiter Herdr-Plugins fährst und Herdrs Socket-API sprichst.

---

## Keybinding- und Vokabular-Spickzettel

Der Wechsel zwischen diesen sieben Tools wird viel leichter, sobald du siehst, wie ihre Nomen und Default-Shortcuts einander zugeordnet sind:

| Aktion / Konzept | tmux | Zellij | Herdr | TuiOS | Rex | Tern | Muxy |
|---|---|---|---|---|---|---|---|
| **Top-Level-Gruppe** | Session | Session | Workspace / Session | Session (gruppiert nach Space) | Session | Session | Projekt |
| **Tab-Ebene** | Window | Tab | Tab | Workspace (1–9) | Window | Tab | Tab |
| **Split / Blatt-Item** | Pane | Pane (tiled / float / stack) | Pane | Window (tiled / float) | Block | Pane, der einen Block fährt | Pane |
| **Default-Prefix / Modus-Taste** | `Ctrl+b` | Modal (`Ctrl+p`, `Ctrl+t`, `Ctrl+g` Lock) | `Ctrl+b` + Maus-UI | `Ctrl+b` + modaler WM-/Terminal-Modus | `Cmd`-Shortcuts + `Ctrl+b`-Chords | `⌘K`-Palette + rebelegbare Chords | `Cmd`-Shortcuts + `Cmd+K`-Palette |
| **Split rechts / vertikal** | `Ctrl+b %` | `Ctrl+p` dann `r` (oder `Alt+n`) | `Ctrl+b v` (oder Maus) | `Ctrl+b v` / `tuios split-window right` | `Cmd+d` / `rex split` | `tern split` / Shortcut | `Cmd+d` / Palette |
| **Split unten / horizontal** | `Ctrl+b "` | `Ctrl+p` dann `d` | `Ctrl+b s` (oder Maus) | `Ctrl+b s` / `tuios split-window down` | `Shift+Cmd+d` | `tern split` / Shortcut | `Shift+Cmd+d` / Palette |
| **Session detachen** | `Ctrl+b d` | `Ctrl+o` dann `d` | `Ctrl+b q` | `Ctrl+b d` / `tuios detach-client` | Fenster schließen (Server persistiert) | Fenster schließen (Daemon persistiert) | Fenster schließen (`muxy-server` persistiert) |
| **Sessions per CLI listen** | `tmux ls` | `zellij ls` | `herdr session list` | `tuios ls` | `rex ls` | `tern ls` | `muxy project list` / Sidebar |

---

## Remote-SSH, Handys und Browser im Vergleich

| Tool | Remote-Transport | Multi-Machine-Ansicht | Handy-Erlebnis | Browser-Client | Unmanaged-Server-fähig |
|---|---|---|---|---|---|
| **tmux** | Schlichtes SSH (oder Mosh + `tmux attach`) | Manuell (`ssh` in Panes) | Generische SSH-Apps (Termius, Blink, Moshi) | Nur Third-Party (`ttyd`, `gotty`) | **Ja** (fast überall vorinstalliert) |
| **Zellij** | Schlichtes SSH (`zellij attach`, auto-nested in 0.45.1) | Manuell (`ssh` in Panes) | Generische SSH-Apps oder mobiler Browser | **Eingebaut** (`zellij web` mit Auth/Read-only-Tokens) | Braucht Single-Binary-Installation |
| **Herdr** | SSH + `herdr --remote` Thin Client | **Ja** (`herdr machine add`-Sidebar) | **Heute am besten** ([Moshi](/control-ai-agents-from-phone-moshi-herdr/) + `moshi-hook`-Push-Freigaben, Heeler) | Community-Web-UIs (ColliePWA, `herdr-web-ui`) | Braucht ~11-MB-Binary auf dem Host |
| **TuiOS** | Eingebauter SSH-Server (`tuios ssh`) + verlinkte Hosts | **Ja** (Remote-Panes in lokaler Session + `tuios cp`) | `tuios pair`-QR-Code + ntfy/Pushover-Inbox-Push-Alerts | Offizielles `tuios-web`-Companion-Binary | Braucht ~16-MB-Binary auf dem Host |
| **Rex** | Eingebautes Rex-Protokoll (echter OS-Login, Mosh-artiges Gefühl) | **Ja** (`rex -S ` + Command Palette) | iOS-Client intern gebaut, noch nicht shipped | Web-Client intern gebaut, noch nicht shipped | Braucht Rex-Server auf dem Host |
| **Tern** | `tern remote serve` über QUIC (oder SSH mit Terminfo) | **Ja** (Hosts-Palette-Umschalter + Remote-Luau-Plugins) | **Native Android-App** (QR-Pairing); iOS als Nächstes | **Eingebaut** (`tern web serve` Wasm + WebGPU-Client) | Braucht Tern-Daemon auf dem Host |
| **Muxy** | SSH zu Remote-`muxy-server` (`muxy --host`, In-App-Install-Angebot) | **Ja** (lokale + Remote-Projekte in einer Sidebar) | **Native iOS- & Android-Apps** (LAN/VPN zu deinem eigenen Server) | Kein Browser-Client | Braucht `muxy-server` auf dem Host |

- **Am besten für Server, die dir nicht gehören:** **tmux**, und nichts anderes kommt heran. Es ist schon auf fast jedem Kundenserver, Container-Host und jeder BSD-Box installiert.
- **Bestes Next-Gen-Remote-Protokoll:** **Rex** (echter System-Login mit Mosh-artiger Responsiveness) und **Tern** (`tern remote serve` über QUIC zu Desktop-, WebGPU-Browser- und Android-Clients). **TuiOS** nimmt den dritten Platz mit seiner Fähigkeit, einen einzelnen Remote-Pane von einem anderen Host direkt in deinen lokalen Workspace zu mounten (`tuios new-window --host build`). **Muxy** verdient hier auch eine Erwähnung: SSH zu einem Remote-`muxy-server` ist das am wenigsten exotische Setup in dieser Gruppe, und die App kann die Serverseite für dich installieren.
- **Bestes Handy-Erlebnis heute:** **Herdr** gepaart mit [Moshi](/control-ai-agents-from-phone-moshi-herdr/) (Mosh-UDP-Transport + `moshi-hook`-Lock-Screen-Approve/Deny-Buttons) oder Heeler, mit **TuiOS** (`tuios pair`-QR-Code + ntfy/Pushover-Inbox-Push-Benachrichtigungen), **Tern** (Android-Client) und **Muxy** (native iOS/Android-Apps, die mit deinem eigenen `muxy-server` sprechen) direkt dahinter.
- **Bestes Browser-Erlebnis:** **Zellij** (`zellij web` mit eingebauter Auth und Read-only-Tokens) und **Tern** (`tern web serve` WebGPU-Client). `tuios-web` und Herdrs Community-Web-UIs (ColliePWA, `herdr-web-ui`) sind super über Tailscale. Muxy hat keinen Browser-Client.

## Welchen Terminal-Multiplexer solltest du wirklich wählen?

| Deine Situation / primärer Workflow | Bester Pick | Zweiter | Warum |
|---|---|---|---|
| **SSH auf Produktions- oder Kunden-Linux-Server** | **tmux** | Zellij | Schon überall installiert, 1,2-MB-Binary, null Setup-Risiko. |
| **Will ein modernes tmux mit auffindbaren Keys & Layouts** | **Zellij** | tmux 3.8 | On-Screen-Key-Hints, KDL-Projekt-Layouts, Floating Panes und eingebautes `zellij web`. |
| **Fährst 3–10+ KI-Coding-Agenten auf Laptop oder VPS** | **Herdr** | TuiOS | Bewährte Stabilität (~44k Stars), Zero-Config-State-Sidebar, Socket-API und Moshi-Handy-Freigaben. |
| **Willst Tiling-Layouts + Worktree-Fan-out & Diff-Review** | **TuiOS** | Herdr | BSP/Scrolling-Tiling, Unified Inbox mit Prompt-Holds, `tuios fan`, `tuios review` und Herdr/tmux-Shims. |
| **macOS-User, der den Multiplexer im Terminal will** | **Rex** | [cmux](/cmux-terminal/) / Tern | `libghostty`-Geschwindigkeit, unabhängiges Client-Scrollback, echte OS-Remote-Logins und Lua-Automation. |
| **Willst Git-, SQLite-, Jupyter- & Kanban-Panes neben deiner Shell** | **Tern** | Zellij + TUI-Tools | Native Blöcke über das Tern Surface Protocol, QUIC-Remoting und native `omp`-Agent-UI. |
| **macOS-User, der eine Open-Source-App mit Agent-Alerts & Handy-Apps will** | **Muxy** | Tern | MIT-lizenziertes Rust-+-GPUI-Terminal auf `libghostty`, 12-Agent-Erkennung mit Benachrichtigungen, Per-Projekt-Worktrees, `muxy-server`-Remoting und iOS/Android-Companions. |

  

    
- Shells, Builds und Logs auf beliebigen Linux-Servern pflegen → tmux. Überall installiert, winziger Footprint, null Überraschungen.
    
- Einen modernen tmux-Ersatz mit auffindbaren Shortcuts, Floating Panes, KDL-Layouts und einer Web-UI → Zellij.
    
- 3+ KI-Coding-Agenten fahren und eine Live-State-Sidebar, Socket-API und Lock-Screen-Handy-Freigaben wollen → Herdr.
    
- Einen Tiling-Window-Manager in deinem Terminal plus eine Inbox, die Prompts hält, Worktrees auffächert und Diffs reviewt → TuiOS.
    
- macOS nutzen und ein schnelles libghostty-Terminal mit eingebauter Session-Persistenz und SSH-ersetzenden Remote-Logins wollen → Rex.
    
- Ein plattformübergreifendes Rust-Terminal mit nativen Git-, SQLite-, Jupyter- und Kanban-Blöcken neben deiner Shell → Tern.
    
- Eine Open-Source-Terminal-App, die Sessions am Leben hält, Agenten markiert, die auf dich warten, und echte iOS/Android-Companions hat → Muxy.
  

### Realwelt-Kombinationen (und die eine Nesting-Regel)

Du musst dich nicht für nur eins entscheiden. Mein eigener Tages-Stack nutzt drei:

1. **tmux** auf Produktionsservern, die ich einmal im Monat anfasse.
2. **Herdr + Moshi** auf einem Always-on-Hetzner-VPS, auf dem langlebige Claude-Code- und Codex-Sessions leben.
3. **TuiOS** (oder **Herdr in Tern**), wenn ich Worktree-Fan-out (`tuios fan`) oder native Git/SQLite-Blöcke auf meiner Workstation will.

Nesting funktioniert gut, solange du **eine Regel** befolgst: Halte eine einzige Multiplexer-Schicht direkt über deinen KI-Coding-Agenten. Herdr in einem Tern-Pane zu fahren funktioniert, weil Tern das äußere Fenster rendert, während Herdr die Agent-PTYs direkt besitzt. `tmux` *zwischen* Herdr/TuiOS und deinem Coding-Agenten zu legen, bricht die automatische Prozessbaum-Erkennung (der äußere Multiplexer sieht `tmux`, nicht `claude` oder `codex`). Wenn ein Tool versucht, `tmux`-Panes unter dir zu spawnen, fahr es stattdessen unter `tuios tmux-shim`, statt einen echten tmux-Server zu nesten.

## FAQ

**Ist tmux 2026 tot?**

  Nein. tmux besitzt immer noch die „auf jedem Server vorinstalliert"-Nische, und tmux 3.8 (September 2026) brachte Floating-Pane-Verbesserungen, einen eingebauten Fuzzy-Session-Switcher (Ctrl+b Tab) und automatische Light/Dark-Themes. Wenn du dich auf eine Maschine einloggst, die du nicht verwaltest, ist tmux das, was da ist. Was sich geändert hat, ist lokale und VPS-Entwicklung mit KI-Coding-Agenten: tmux hat kein Konzept von Agent-State oder Prompt-Freigaben, weshalb Herdr und TuiOS so schnell gewachsen sind.

**tmux vs Zellij: was ist besser für normale Terminal-Arbeit?**

  Wenn du heute frisch startest und die Maschinen kontrollierst, auf denen du arbeitest, lernt sich Zellij schneller dank seiner On-Screen-Key-Hints, Default-Maus-Support, KDL-Projekt-Layouts, eingebauter Session-Resurrection, First-Class-Nested-Sessions (v0.45+) und zellij web-Browser-Zugang. Wenn du regelmäßig über Kundenserver, minimale Container oder BSD-Boxen hüpfst oder auf iTerm2s tmux -CC-Integration angewiesen bist, bleib bei tmux.

**Kann ich zwei Terminal-Multiplexer zusammen fahren?**

  Ja, mit einer Regel: Halte eine einzige Multiplexer-Schicht direkt über deinen KI-Coding-Agenten. Herdr in Tern zu fahren funktioniert, weil Tern das äußere Fenster rendert, während Herdr die Agent-PTYs direkt besitzt. tmux in Herdr (oder Herdr in tmux) zu legen, bricht die automatische Agent-Erkennung, außer du konfigurierst explizite Lifecycle-Hooks. TuiOS enthält außerdem tuios tmux-shim, das tmux-CLI-Calls in native TuiOS-Fenster übersetzt, sodass du tmux gar nicht nesten musst.

**Was ist der beste Terminal-Multiplexer für einen headless VPS?**

  Für klassische Sysadmin-Arbeit und langlebige Builds: tmux. Für einen headless VPS, der Claude Code, Codex oder OpenCode 24/7 fährt, nimm Herdr oder TuiOS: Beide halten Sessions auf dem Server am Leben und geben dir eine Agent-State-Sidebar oder Inbox, die du von deinem Laptop oder Handy über Tailscale erreichst. Siehe unser Phone-Control-Setup mit Moshi und Herdr für den Schritt-für-Schritt-Stack.

**Sind alle sieben Terminal-Multiplexer kostenlos und Open Source?**

  Fünf sind kostenlos und Open Source: tmux (ISC), Zellij (MIT), Herdr (Apache-2.0), TuiOS (MIT) und Muxy (MIT). Superlogical Rex ist Closed Source, wenngleich Superlogical verspricht, dass der Rex-Client und -Server „kostenlos ist und immer sein wird", self-hostbar ohne Account. Stencil Tern ist Closed Source in geschlossener Beta und hat noch keine Preise angekündigt.

**Welcher Terminal-Multiplexer ist der stabilste für den täglichen Einsatz?**

  tmux und Zellij, mit großem Abstand. Beide sind reif, stabil und berechenbar. Unter den Agent-first-Tools ist Herdr (v0.9.3, ~44k Stars) der bewährtere Daily Driver, während TuiOS (v0.11.1) Features in rapidem Tempo shipped, falls dich häufige Updates nicht stören. Rex und Tern sind beide noch hinter Beta-Einladungen. Muxy ist der jüngste der Gruppe: die 2.x-Linie ist gerade erst shipped, mit einem separaten Beta-Channel, der Features zuerst bekommt, aber sie ist voll offen, MIT-lizenziert und heute herunterladbar.

## Fazit

Es gibt hier keinen einzelnen Gewinner, weil sich die Kategorie in drei getrennte Jobs aufgespalten hat:

1. **Klassisches Shell-Multiplexing:** **tmux** bleibt unantastbar auf Remote-Servern, die dir nicht gehören, und **Zellij** ist das beste moderne Upgrade, wenn du KDL-Layouts, Floating Panes, Nested SSH Sessions und On-Screen-Key-Hints willst, ohne ein Wochenende an einer Config-Datei zu verbringen.
2. **KI-Agent-Multiplexing:** **Herdr** ist heute der sicherste Pick, um eine Flotte von Coding-Agenten über lokale und Remote-Maschinen zu beaufsichtigen, während **TuiOS** der ehrgeizigste Herausforderer ist mit seinem Tiling-Window-Manager, der Unified Inbox, Inline-Diff-Review, Worktree-Fan-out und Herdr/tmux-Kompatibilitäts-Shims.
3. **Next-Gen-Terminal-Apps:** **Rex**, **Tern** und **Muxy** beweisen, dass das Einbacken von Session-Persistenz und Remoting ins Terminal selbst schneller und sauberer ist als eine TUI in einer TUI zu fahren: Rex für `libghostty`-Puristen auf macOS, Tern für Entwickler, die Git, SQLite, Kanban und Notebooks direkt neben ihrem Prompt wollen, und Muxy für dieselbe Architektur als Open Source (MIT) mit eingebauter Agent-State-Erkennung und iOS/Android-Companions.

Wenn dein Terminal-Tag hauptsächlich aus Shells und Logs besteht, installiere tmux oder Zellij und geh zurück an die Arbeit. Wenn die Hälfte deiner Panes KI-Coding-Agenten sind, wechsle zu einem Multiplexer, der weiß, dass sie drin sind.

[Herdr auf GitHub](https://github.com/herdrdev/herdr)
[TuiOS Docs](https://tuios.dev/docs)
[Zellij auf GitHub](https://github.com/zellij-org/zellij)
[Muxy auf GitHub](https://github.com/muxy-app/muxy)