Ein Entwickler-Leitfaden zu tmux im Zeitalter der KI

tmux ist ein Terminal-Multiplexer: Er betreibt einen persistenten Serverprozess auf Ihrem Rechner, sodass Sessions, Windows und Panes auch bei Verbindungsabbrüchen erhalten bleiben – Sie können sich von einer Session trennen, Ihren Laptop schließen, sich von einem anderen Rechner per SSH einloggen und die Session wieder aufrufen, um jeden Prozess genau dort vorzufinden, wo Sie ihn verlassen haben. Diese eine Eigenschaft ist der Grund, warum tmux heute wichtiger ist als noch vor einem Jahrzehnt: Entwickler betreiben zunehmend langlebige Prozesse – Dev-Server, Build-Watcher und autonome KI-Coding-Agenten wie Claude Code und aider –, die eine instabile SSH-Verbindung oder einen zugeklappten Laptop überdauern müssen.

Dieser Leitfaden vermittelt zunächst das konzeptionelle Grundverständnis (Sessions, Windows, Panes, der Prefix-Key), stellt eine minimale Konfiguration vor, die Sie einmalig einfügen und danach nicht mehr anfassen müssen, und widmet sich dann ausführlich dem Thema, das kein anderer tmux-Leitfaden behandelt: tmux als dauerhaften Host für KI-Coding-Agenten zu nutzen. Abschließend folgt ein ehrlicher Vergleich, wann tmux die richtige Wahl ist und wann ein modernes Terminal wie Zellij oder Warp das bessere Werkzeug darstellt.

Was tmux ist und welches Problem es löst

tmux ist ein Terminal-Multiplexer, der es einem einzigen Terminalfenster ermöglicht, viele persistente Sessions, Windows und Panes zu hosten. Der Mechanismus hinter dieser Persistenz ist eine Client-Server-Architektur: Wenn Sie tmux ausführen, startet es einen langlebigen Serverprozess, der Ihre Sessions verwaltet, während sich Ihr Terminal als Client mit diesem Server verbindet. Wenn Ihre SSH-Verbindung abbricht, bleibt Ihre tmux-Session bestehen – denn der Serverprozess läuft unabhängig von jeder Client-Verbindung. Ihr Terminal ist lediglich eine Ansicht; die Session läuft weiter, egal ob Sie verbunden sind oder nicht.

tmux löst zwei Probleme gleichzeitig. Das erste ist Persistenz: Ein Build, der 40 Minuten dauert, ein Dev-Server oder ein KI-Agent mitten in einer Aufgabe laufen alle weiter, nachdem Ihre ssh-Session beendet wurde. Sie verbinden sich erneut und hängen sich wieder an. Das zweite ist das Layout: Anstatt mit Terminal-Tabs zu jonglieren, teilen Sie ein Fenster in Panes auf – Editor links, ein Server-Log rechts, eine Shell unten –, alles gleichzeitig sichtbar und jederzeit reproduzierbar.

tmux wurde 2007 von Nicholas Marriott als ISC-lizenzierte Alternative zu GNU screen entwickelt. Die Beispiele in diesem Leitfaden verwenden tmux 3.6b. Installieren Sie es über Ihren Paketmanager:

# macOS
brew install tmux

# Debian / Ubuntu / WSL
sudo apt install tmux

# Fedora / RHEL
sudo dnf install tmux

tmux -V   # Version überprüfen

Die Hierarchie: Sessions, Windows und Panes

tmux organisiert die Arbeit in drei Ebenen: Eine Session ist ein benannter, persistenter Arbeitsbereich (einer pro Projekt); Windows sind Tabs innerhalb dieser Session; Panes sind Splits innerhalb eines Windows. Der Prefix-Key – standardmäßig Ctrl+b, üblicherweise auf Ctrl+a umbelegt – ist das Tor zu jedem tmux-Befehl. Sie drücken den Prefix, lassen ihn los und drücken dann die Befehlstaste.

Die treffendste Analogie lässt sich auf einen Editor übertragen, den Sie bereits kennen: Eine Session entspricht einem vollständigen Editor-Fenster für ein Projekt, Windows sind die Tabs darin, und Panes sind die geteilten Ansichten innerhalb eines Tabs. Sie könnten eine frontend-Session und eine backend-Session haben; innerhalb von backend ein Window für die Anwendung und eines für die Datenbank; innerhalb des Anwendungs-Windows einen Pane, der den Server ausführt, und einen für Ad-hoc-Befehle.

Da der Prefix alle Befehle absichert, setzt jede der folgenden Tastenbelegungen voraus, dass Sie zuerst den Prefix drücken. Der Standard-Prefix ist Ctrl+b; die Konfiguration im nächsten Abschnitt belegt ihn auf Ctrl+a um, was ergonomisch günstiger ist.

Die wesentlichen Befehle

Diese Befehle decken 90 % der täglichen tmux-Nutzung ab: Sessions erstellen und benennen, trennen und wieder verbinden, Panes aufteilen und navigieren sowie durch die Ausgabe zurückscrollen. Befehle auf Session-Ebene führen Sie in Ihrer Shell aus; Pane- und Window-Befehle werden innerhalb von tmux über den Prefix eingegeben.

Session-Verwaltung aus der Shell:

tmux new -s project       # eine benannte Session erstellen
tmux ls                   # laufende Sessions auflisten
tmux attach -t project    # Session wieder aufrufen
tmux kill-session -t project

Innerhalb einer Session, mit dem Prefix (hier als umgelegtes Ctrl+a dargestellt):

• prefix d — Trennen (Detach); die Session läuft im Hintergrund weiter.
• prefix c — Ein neues Window erstellen.
• prefix n / prefix p — Nächstes / vorheriges Window.
• prefix % — Den aktuellen Pane vertikal teilen (links/rechts).
• prefix " — Horizontal teilen (oben/unten).
• prefix + Pfeiltasten — Zwischen Panes wechseln.
• prefix z — Den aktuellen Pane auf Vollbild zoomen; erneut drücken zum Wiederherstellen.
• prefix [ — Copy-Mode zum Scrollen und Suchen aufrufen; im vi-Mode sucht /, n/N springt zwischen Treffern, q beendet den Mode.

Der Detach/Reattach-Zyklus ist der zentrale Arbeitsablauf: Mit prefix d trennen, zu einem anderen Rechner wechseln, mit tmux attach -t project-name wieder verbinden und genau dort weitermachen, wo Sie aufgehört haben. Für eine vollständige Referenz der Tastenbelegungen empfiehlt sich ein tmux-Spickzettel – die gesamte Man-Page auswendig zu lernen ist nicht notwendig.

Eine minimale ~/.tmux.conf, die Sie einmalig einfügen können

Eine minimale tmux-Konfiguration benötigt genau vier Dinge: einen neu zugewiesenen Prefix-Key (Ctrl+a ist ergonomisch günstiger als Ctrl+b), Mausunterstützung (set -g mouse on), den vi-Copy-Mode und intuitive Split-Tastenbelegungen – alles andere ist kosmetischer Natur und kann warten. Hier ist diese Konfiguration, mit einem Kommentar zu jeder Zeile, der den Zweck erklärt. Fügen Sie sie in ~/.tmux.conf ein und laden Sie sie mit tmux source-file ~/.tmux.conf neu.

# --- prefix -------------------------------------------------
unbind C-b                 # Standard-Prefix entfernen
set -g prefix C-a          # Ctrl+a liegt näher an der Grundreihe
bind C-a send-prefix       # Ctrl+a zweimal drücken, um ein wörtliches Ctrl+a zu senden

# --- Benutzerfreundlichkeit ---------------------------------
set -g mouse on            # Panes anklicken, Ränder ziehen, nativ scrollen
set -g history-limit 10000 # Mehr Scrollback als der Standard von 2000
set -g base-index 1        # Windows ab 1 nummerieren, nicht ab 0
setw -g pane-base-index 1  # Panes ebenfalls ab 1 nummerieren

# --- Copy-Mode ----------------------------------------------
setw -g mode-keys vi       # vi-Tasten im Copy-Mode
bind v copy-mode           # prefix v zum schnellen Aufrufen des Copy-Mode

# --- Intuitivere Splits -------------------------------------
bind | split-window -h -c "#{pane_current_path}"  # | teilt links/rechts
bind - split-window -v -c "#{pane_current_path}"  # - teilt oben/unten
# beide öffnen im Verzeichnis des aktuellen Panes

# --- Neu laden ----------------------------------------------
bind r source-file ~/.tmux.conf \; display "reloaded"

Einige Hinweise zu Syntax und Versionen. set -g mouse on ist die korrekte Einzeloption für tmux 2.1 und neuer; tmux 2.1 (2015) fasste die vier älteren Optionen (mode-mouse, mouse-select-pane, mouse-resize-pane, mouse-select-window) zu einer zusammen. Wenn Sie in einer alten Konfiguration mode-mouse on finden, erklärt das, warum sie anders aussieht. Das Flag -c "#{pane_current_path}" bewirkt, dass neue Splits das aktuelle Verzeichnis übernehmen – eine Kleinigkeit, die sofort auffällt, wenn sie fehlt.

Das ist die vollständige Konfiguration. Widerstehen Sie der Versuchung, am ersten Tag ein Status-Bar-Theme hinzuzufügen. Wenn Sie später eines möchten, erfordert das Catppuccin tmux-Plugin (aktueller Tag v2.3.0) tmux 3.2+, und sein README empfiehlt einen manuellen Clone gegenüber dem Plugin-Manager aufgrund eines Namenskonflikts.

Moderne Arbeitsabläufe: tmux als Host für KI-Coding-Agenten

tmux ist der natürliche Host für langlebige KI-Coding-Agenten. Trennen Sie eine Claude Code- oder aider-Session, bevor Sie Ihren Laptop schließen, verbinden Sie sich von einem beliebigen Rechner mit tmux attach -t agent wieder, und der Prozess des Agenten – samt vollständigem Ausgabeverlauf – wartet auf Sie. Sowohl Claude Code als auch aider sind Terminal-CLIs, weshalb dies keine spezielle Integration darstellt: Es ist das Standardverhalten jedes Vordergrundprozesses, der unter einer tmux-Session läuft, angewendet auf ein Werkzeug, das viele Minuten lang unbeaufsichtigt laufen kann.

Agentische Coding-Sessions sind genau die Arbeitslast, für deren Schutz tmux konzipiert wurde. Ein Agent, der eine große Codebasis refaktoriert oder eine lange Test-Schleife durchläuft, ist ein Prozess, den Sie nicht an die Lebensdauer Ihrer SSH-Verbindung koppeln möchten. Starten Sie ihn innerhalb von tmux, und er übersteht den Verbindungsabbruch.

Einem Agenten bei der Arbeit zusehen

Das nützlichste Layout ist ein Agent in einem Pane und ein Editor in einem anderen, nebeneinander. Starten Sie eine Session, teilen Sie sie auf und führen Sie den Agenten auf einer Seite aus:

tmux new -s agent
# innerhalb der Session:
#   prefix |   -> links/rechts teilen
#   linker Pane:  claude   (oder: aider)
#   rechter Pane: nvim .

Sie beobachten die Überlegungen und Diffs des Agenten auf der linken Seite, während Sie auf der rechten Seite prüfen oder bearbeiten – alles in einem Window, alles verbindungsresistent.

Mehrere Agenten mit synchronisierten Panes überwachen

Wenn Sie mehrere Agenten parallel betreiben – etwa dieselbe Aufgabe auf verschiedenen Branches –, ermöglichen synchronisierte Panes eine gemeinsame Steuerung. Mit setw -g synchronize-panes on wird jeder Tastendruck, den Sie eingeben, gleichzeitig an alle Panes im Window gesendet. Dies ist nützlich, um denselben Prompt an mehrere Agenten-Sessions zu senden oder eine Reihe paralleler Prozesse gleichzeitig zurückzusetzen. Deaktivieren Sie es auf dieselbe Weise (synchronize-panes off), wenn Sie wieder mit einem einzelnen Pane interagieren möchten. Ein häufiger Fehler bei synchronisierten Panes ist, zu vergessen, dass die Synchronisierung aktiv ist, und versehentlich einen destruktiven Befehl an alle Panes zu senden – binden Sie die Funktion daher an eine Taste mit einem sichtbaren Indikator, damit ihr Status immer eindeutig erkennbar ist.

Ein geskriptetes Agenten-Layout

Um ein reproduzierbares Drei-Pane-Überwachungslayout zu erhalten – Agent links, Editor oben rechts, Logs unten rechts –, ohne zusätzliche Abhängigkeiten, legen Sie dieses Skript unter ~/bin/tmux-agent.sh ab:

#!/usr/bin/env bash
set -euo pipefail
SESSION="agent"

# Erster Pane: der Agent (links). -d erstellt die Session getrennt (detached).
tmux new-session -d -s "$SESSION" -x "$(tput cols)" -y "$(tput lines)"
tmux send-keys -t "$SESSION" "claude" C-m          # Agent, links

# Rechte Seite für den Editor aufteilen; der neue Pane wird aktiv.
tmux split-window -h -t "$SESSION"
tmux send-keys -t "$SESSION" "nvim ." C-m          # Editor, oben rechts

# Den rechten Pane für Logs aufteilen; der neue Pane wird aktiv.
tmux split-window -v -t "$SESSION"
tmux send-keys -t "$SESSION" "tail -f dev.log" C-m # Logs, unten rechts

# Den Agenten-Pane fokussieren und verbinden. Die Zielangabe per Richtung (-L)
# statt hartcodierter Pane-Indizes funktioniert unabhängig von base-index.
tmux select-pane -t "$SESSION" -L
tmux attach -t "$SESSION"

Führen Sie einmalig chmod +x ~/bin/tmux-agent.sh aus, dann tmux-agent.sh bei jedem Arbeitsbeginn. Der Agent läuft weiter, wenn Sie sich trennen; verbinden Sie sich von überall wieder.

Persistenz und Plugins

tmux-Sessions überstehen Verbindungsabbrüche, aber keinen Neustart des Rechners – dafür benötigen Sie Plugins, die den Zustand serialisieren und wiederherstellen. Der Standardstack besteht aus dem Tmux Plugin Manager (TPM) sowie tmux-resurrect und tmux-continuum. Installieren Sie TPM mit:

git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

Fügen Sie dann die Plugin-Zeilen am Ende von ~/.tmux.conf hinzu und drücken Sie prefix + I zur Installation:

set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'
run '~/.tmux/plugins/tpm/tpm'   # diese Zeile muss zuletzt stehen

Verstehen Sie, was jedes Plugin tatsächlich tut. tmux-resurrect speichert und stellt Ihr Session-Layout automatisch wieder her – Windows, Panes und Arbeitsverzeichnisse. Die Wiederherstellung der laufenden Programme ist optional und auf eine konfigurierte Whitelist (@resurrect-processes) beschränkt, wobei Editor-Sessions über @resurrect-strategy-vim/nvim behandelt werden und Pane-Inhalte nur dann erhalten bleiben, wenn @resurrect-capture-pane-contents 'on' gesetzt ist. Gehen Sie nicht davon aus, dass Ihr Agent sich bei der Wiederherstellung selbst neu startet – das geschieht nur, wenn Sie ihn auf die Whitelist gesetzt haben.

tmux-continuum automatisiert das Speichern standardmäßig alle 15 Minuten (konfigurierbar über @continuum-save-interval) und stellt beim Start des tmux-Servers nur dann wieder her, wenn @continuum-restore 'on' aktiviert ist. Zusammen bedeuten diese Plugins, dass ein Neustart lediglich ein Neuladen des Layouts kostet und kein Neuaufbau von Grund auf erforderlich ist.

Deklarative Layouts mit tmuxp

Für Layouts, die Sie wiederholt starten, definieren Sie diese einmalig in YAML mit tmuxp (Repository: tmux-python/tmuxp) oder dem Ruby-basierten Tmuxinator. tmuxp liest Konfigurationen aus dem XDG-Verzeichnis ~/.config/tmuxp/ (der ältere Pfad ~/.tmuxp/ funktioniert weiterhin). Hier ist das Agenten-Überwachungslayout als ~/.config/tmuxp/agent.yaml:

session_name: agent
windows:
  - window_name: supervise
    layout: main-vertical
    shell_command_before:
      - cd ~/code/project
    panes:
      - claude
      - nvim .
      - tail -f dev.log

Laden Sie es mit tmuxp load agent. Die Schlüssel hier – session_name, windows, window_name, layout, shell_command_before, panes – sind alle aktuell in tmuxp 1.70.x. Dies ist das deklarative Äquivalent des Bash-Skripts oben: ein Befehl, dasselbe reproduzierbare Layout jedes Mal.

Wann tmux NICHT verwendet werden sollte

Wenn Sie ausschließlich lokal arbeiten und sich weder per SSH in entfernte Rechner einloggen noch langlebige Hintergrundprozesse betreiben, bietet ein modernes Terminal wie Zellij oder Warp Multiplexing mit besseren Standardeinstellungen und ohne die Lernkurve des Prefix-Key-Modells. Der Vorteil von tmux liegt spezifisch in seiner serverseitigen Persistenz und Skriptbarkeit über SSH. tmux einzusetzen, wenn die nativen Tabs Ihres Terminals ausreichen würden, bedeutet zusätzliche Komplexität ohne Mehrwert.

Einige entscheidende Anmerkungen: Zellij ist ein in Rust geschriebener Multiplexer mit einem modusbasierten System anstelle eines einzelnen Prefix-Keys, integrierter Session-Persistenz und Serialisierung sowie einem optionalen tmux-ähnlichen Prefix-Preset; er befindet sich in aktiver Entwicklung und ist noch vor Version 1.0. Warp ist ein plattformübergreifendes Terminal – macOS, Linux und Windows – mit KI-integrierten Befehlsvorschlägen, dessen Client im April 2026 als Open Source (MIT + AGPL v3) veröffentlicht wurde, sodass es unter Linux eine vollwertige Option darstellt und kein reines macOS-Werkzeug ist. Verwenden Sie tmux, wenn Sie sich per SSH in entfernte Rechner einloggen, langlebige Prozesse betreiben (Build-Watcher, Dev-Server, KI-Agenten) oder skriptierte, reproduzierbare Layouts benötigen. Verwenden Sie ein modernes Terminal, wenn Sie diese Funktionen mit weniger Aufwand wünschen und die Skripttiefe oder Plugin-Breite von tmux nicht benötigen.

Fazit

Der Grund, warum tmux in einem agentenlastigen Arbeitsablauf seinen Platz verdient, ist derselbe, der ihm schon vor Jahren über SSH seinen Platz gesichert hat: Es entkoppelt einen laufenden Prozess von dem Terminal, das ihn beobachtet. Starten Sie Ihren nächsten langen Agenten-Lauf innerhalb von tmux new -s agent, trennen Sie sich, wenn Sie eine Pause machen, und verbinden Sie sich von wo auch immer wieder – die Arbeit läuft ohne Sie weiter. Fügen Sie die obige minimale Konfiguration ein, ergänzen Sie tmux-resurrect, wenn Neustarts Sie Layouts kosten, und skripten Sie das Agenten-Layout einmalig, damit Sie es nie wieder von Hand aufbauen müssen.

Häufig gestellte Fragen

Was passiert mit einem in tmux laufenden Prozess, wenn der tmux-Server beendet wird oder der Rechner neu startet?

Der Prozess wird beendet. Die tmux-Persistenz schützt nur vor Client-Verbindungsabbrüchen, nicht vor einem Server-Shutdown. Das Beenden des Servers mit tmux kill-server oder ein Neustart des Rechners beendet jeden laufenden Prozess und verwirft jede Session. Um einen Neustart zu überstehen, benötigen Sie tmux-resurrect zum Speichern des Layouts und tmux-continuum zur Wiederherstellung beim Server-Start. Auch dann wird jedoch nur das Layout wiederhergestellt, nicht die laufenden Programme – es sei denn, Sie haben bestimmte Prozesse über die resurrect-processes-Option auf die Whitelist gesetzt.

Was ist der Unterschied zwischen tmux-Windows und Panes?

Ein Window ist ein Vollbild-Tab innerhalb einer Session, und ein Pane ist ein geteilter Bereich innerhalb eines einzelnen Windows. Beim Wechsel zwischen Windows wird der gesamte Bildschirm mit einem anderen Tab ersetzt, was über prefix n oder prefix p erfolgt. Panes hingegen teilen ein sichtbares Window in nebeneinander oder übereinander angeordnete Bereiche auf, zwischen denen Sie mit prefix und den Pfeiltasten navigieren. Verwenden Sie Windows, um unterschiedliche Aufgaben zu trennen, etwa eine Anwendung und ihre Datenbank, und Panes, um verwandte Prozesse gleichzeitig zu sehen, beispielsweise einen Editor neben einem Live-Log.

Muss ich den Prefix-Key von Ctrl+b auf Ctrl+a umbelegen?

Nein, die Umbelegung ist optional und eine reine Ergonomie-Entscheidung. Der Standard-Prefix Ctrl+b funktioniert für jeden tmux-Befehl ohne jegliche Konfiguration. Viele Benutzer belegen ihn auf Ctrl+a um, weil die Tasten auf der Tastatur näher beieinander liegen. Dies steht jedoch im Konflikt mit derselben Belegung in GNU screen und mit dem readline-Kürzel, das den Cursor an den Anfang einer Zeile bewegt. Wenn Sie auf Ctrl+a umbelegen, fügen Sie bind C-a send-prefix hinzu, damit ein doppeltes Drücken weiterhin ein wörtliches Ctrl+a an die Shell sendet.

Sollte ich tmux oder Zellij für die Ausführung von Coding-Agenten über SSH verwenden?

Beide funktionieren, da jedes einen Server auf dem entfernten Host betreibt, der Sessions über Verbindungsabbrüche hinaus am Leben erhält. Die Wahl hängt daher von Standardeinstellungen und Ökosystem ab. Wählen Sie tmux, wenn Sie ein großes, ausgereiftes Plugin-Ökosystem, tiefe Skriptbarkeit über bash oder tmuxp und Tastenbelegungen wünschen, die auf den meisten Servern bereits installiert sind. Wählen Sie Zellij, wenn Sie intuitive modusbasierte Steuerung gegenüber einem Prefix-Key-Modell bevorzugen und Session-Serialisierung ohne Plugin-Konfiguration wünschen. Da Zellij noch vor Version 1.0 ist, ist tmux die konservativere Wahl für langlebige Setups.