---
title: "cmux Terminal: Praxis-Guide für KI-Coding-Agents unter macOS"
description: "Lerne cmux Terminal unter macOS: installieren, KI-Coding-Agents in Workspaces betreiben, den Browser automatisieren, Benachrichtigungen verdrahten – und cmux vs. tmux und Ghostty."
date: 2026-03-13
categories: ["ai"]
tags: ["cmux","ghostty","tmux"]
---

Wenn dein Tag aus drei Coding-Agents, einem Dev-Server und einem Browser besteht, zu dem du ständig per Alt-Tab springst, ist das **cmux Terminal** genau für dieses Chaos gebaut. Es ist ein natives macOS-Terminal für KI-Coding-Agents, das jede Session sichtbar hält, dich anpingt, wenn eine Eingabe nötig ist, und eine CLI bereitstellt, mit der du den ganzen Workspace automatisierst.

Viele KI-Tools wollen deinen Workflow ersetzen. cmux bleibt näher an „hier sind die Bausteine, bau dir dein eigenes Setup". Genau diese Haltung ist der Grund, warum es diesen Guide gibt.

Am Ende weißt du, wie du cmux unter macOS installierst und verifizierst, wie der Agent-Workflow zusammenspielt (Workspaces, Benachrichtigungen, Browser-Automatisierung, Session-Resume) und wann cmux vs. tmux und Ghostty sinnvoll ist. Wenn du noch entscheidest, welche Agents du fahren willst, ist mein Guide [AI-Coding-Tools und Agents im Vergleich](/ai-coding-tools/) die passende Begleitlektüre.

- cmux unter macOS installieren und prüfen, dass CLI und Socket antworten
- Claude Code, Codex oder OpenCode in Benachrichtigungen und Session-Resume einbinden
- Ein ehrliches cmux-vs-tmux-Urteil bekommen statt Marketing-Text

**Was cmux ist, in einem Satz**

cmux ist eine native macOS-Terminal-App auf Basis von `libghostty` – mit Workspaces, Panes, Benachrichtigungen, Browser-Automatisierung und einer CLI/Socket-API, mit der du das Ganze steuerst.

## Was cmux wirklich ist

![cmux-Terminal-UI mit vertikalen Workspaces, Agent-Panes und Benachrichtigungs-Badges](@assets/images/26/03/cmux-ui.webp)

cmux ist **kein** Ghostty-Fork. Es nutzt `libghostty` fürs Terminal-Rendering – so wie eine App WebKit für Webinhalte nutzen würde. Du bekommst also Ghostty-artiges Rendering und Config-Kompatibilität in einer anderen App. Es ist mit Swift und AppKit gebaut und liest `~/.config/ghostty/config` für Themes, Fonts und Farben – ein bestehendes Ghostty-Setup lässt sich also übernehmen. Mein [Ghostty-Terminal-Setup-Guide](/de/ghostty-terminal/) behandelt diese Config-Datei im Detail.

Die Idee ist simpel:

- Mehrere Coding-Agents parallel öffnen
- Sie sauber nach Workspace, Pane oder Browser-Surface getrennt halten
- Ein klares visuelles Signal bekommen, wenn einer Eingabe braucht
- Terminal und Browser per Skript oder Hooks automatisieren

Das bildet ein kleines Objektmodell ab: **Window → Workspace → Pane → Surface**. Mehr dazu gleich – denn genau dieser Teil macht Multi-Agent-Arbeit erträglich.

Ein Lizenz-Hinweis, bevor du über Self-hosting irgendetwas nachdenkst: Die Core-App steht unter **GPL-3.0-or-later**, aber einige serverseitige Teile (`web/`, die `workers/`-Verzeichnisse, `cmux-tui/relays/cloudflare-do/`) stehen unter **BUSL-1.1** und brauchen für den Produktiveinsatz – inklusive Self-hosting – eine kommerzielle Lizenz von Manaflow. Für den lokalen macOS-Workflow in diesem Guide ist das egal. Die [LICENSE](https://github.com/manaflow-ai/cmux/blob/main/LICENSE) enthält die genaue Aufteilung.

## Warum cmux bei KI-Coding-Agents Aufmerksamkeit bekommt

Niemand braucht „noch ein Terminal". Der interessante Teil ist, wie cmux Multi-Agent-Arbeit handhabt, ohne dich in ein geschlossenes Orchestrierungs-Produkt zu zwingen.

Laut offiziellem README, Docs und Changelog (geprüft im November 2026) bekommst du mit dem cmux Terminal:

- Eine native macOS-App aus Swift und AppKit (macOS 14+, Apple Silicon oder Intel)
- Ein Ghostty-betriebenes Terminal, das deine bestehende Ghostty-Config für Themes, Fonts und Farben liest
- Vertikale Tabs und Split-Panes zum Jonglieren mehrerer Workspaces
- Notification-Ringe, Unread-Badges, ein Notification-Panel und macOS-Desktop-Benachrichtigungen
- Einen eingebauten Browser mit skriptbarer Befehlsfläche
- Eine CLI- und Unix-Socket-API zum Senden von Text, Auslesen von Screens, Öffnen von Panes, Verschieben von Surfaces und mehr
- Agent-Session-Resume via Hooks (15+ Agents) und ein einmaliges `cmux hooks setup`
- SSH-Workspaces (`cmux ssh`) und Remote-tmux-Attach via `cmux ssh-tmux` (Beta)
- Skills, wiederverwendbare Workflows, die jeder Agent in cmux ausführen kann (öffentliche Sammlung in `manaflow-ai/cmux-skills`)
- Claude Code Teams und Subagent-Panes (`cmux claude-teams`), sodass Subagents zu nativen Splits statt versteckten Prozessen werden
- OSC-7501-Program-Status plus eine Sidebar-Metadata-CLI (`set-status`, `set-progress`, `log`) für Agent- und CI-Hooks

Zur Glaubwürdigkeit: Das Repo hatte am 16.11.2026 28.794 Stars und 2.673 Forks – rund zehn Monate nach Erstellung. Mitchell Hashimoto (Ghostty, HashiCorp) hat es öffentlich gelobt. Das ehrliche Aber: 7.084 offene Issues am selben Datum. Sehr aktives Projekt, schwerer Backlog – beides stimmt.

Und die Kostenzeile, die für diesen Guide zählt: **Alles hier Beschriebene läuft im Free-Tier (0 $)**. Bezahlte Pläne werden erst relevant, wenn du Agents auf Remote-VMs willst.

## Was das cmux Terminal kann

### Mehrere KI-Coding-Agents fahren, ohne den Überblick zu verlieren

cmux nutzt vier Ebenen, damit Arbeit getrennt bleibt. Das Window ist das App-Fenster. Ein Workspace ist der vertikale Haupt-Tab in der Sidebar. Ein Pane ist ein Split-Bereich innerhalb eines Workspaces. Eine Surface ist der eigentliche Terminal- oder Browser-Tab innerhalb eines Panes.

![cmux-Hierarchiediagramm: die Ebenen Window, Workspace, Pane und Surface](@assets/images/26/03/cmux-hierarchy.svg)

Dieses Modell klingt erst mal schwerer als ein normales Terminal. In der Praxis ist es die Art, wie cmux mehrere Agents, mehrere Splits und Browser-Tabs zeigt, ohne zu einem Tab-Haufen zu zerfallen. Workspace-Gruppen halten verwandte Projekte zusammen, und die globale Session-Suche (⌘⌥F) findet offene Claude-Code- oder Codex-Sessions anhand ihres Gesprächstexts.

**Affiliate-Hinweis**

Einige Links in diesem Artikel sind Affiliate-Links. Sie kosten dich nichts extra und helfen, die Seite zu finanzieren.

Wenn du mehrere Modell-CLIs fährst und einen Router davor willst, schau dir [Agent Router zum Routen zwischen Claude Code, Codex und Gemini CLI](https://go.bitdoze.com/agentrouter) an. Wenn du den reinen Multiplexer-Ansatz ohne GUI willst, behandelt mein [Herdr-Agent-Multiplexer-Review](/de/herdr-agent-multiplexer/) eine Alternative, die man kennen sollte.

### Erkennen, welcher Agent Aufmerksamkeit braucht

Hier hat cmux die Details im Griff.

Statt einer generischen Desktop-Meldung kann cmux zeigen:

- einen Notification-Ring um den Pane
- ein Unread-Badge am Workspace
- ein Notification-Panel mit ausstehenden Einträgen
- eine Desktop-Benachrichtigung unter macOS

Es unterstützt die üblichen Terminal-Notification-Escape-Sequenzen (OSC 9, OSC 99, OSC 777) und stellt `cmux notify` für Skripte und Hooks bereit.

![cmux-Notification-Flow-Diagramm: von Hooks und OSC-Escapes zu Ringen, Badges, Panel und Desktop-Alerts](@assets/images/26/03/cmux-notify-flow.svg)

Neuere Builds bringen OSC-7501-Program-Status mit: Ein Programm meldet idle, working, blocked, done oder error, und cmux zeigt das als Sidebar-Pill und im `cmux-events`-Stream. Probier es aus jedem cmux-Terminal:

```bash
printf '\e]7501;state=working\e\\'
```

Damit kannst du Claude Code, Codex, OpenCode oder deine eigenen Shell-Skripte in denselben Notification-Flow hängen. Wenn du Codex nutzt, schau dir an, wie man [die Codex-App mit beliebigen Modellen fährt](/codex-app-any-model/). Für OpenCode-Nutzer hilft mein [OpenCode-vs-Pi-Agent-Vergleich](/de/opencode-vs-pi-agent/) bei der Wahl, welcher Agent in den Pane kommt.

### Den eingebauten Browser über die CLI automatisieren

Die Browser-Surface ist das, was cmux von Ghostty und tmux abhebt. Eine Browser-Surface sitzt neben dem Terminal im selben Pane, und du steuerst sie von der Kommandozeile:

```bash
cmux browser open https://localhost:4321
cmux browser snapshot --interactive
cmux browser fill "#email" --text "me@example.com"
cmux browser click "button[type='submit']" --snapshot-after
cmux browser wait --text "Welcome" --timeout-ms 10000
```

Achte auf das `--text`-Flag bei `fill` (die Positional-Form funktioniert weiterhin, aber die Docs nutzen Flags) und `--snapshot-after` bei `click`. Das Snapshot-after-Flag ist der Verifikationsschritt: Es dumpt den Seiten-Zustand nach der Aktion, damit du siehst, was wirklich passiert ist. Wenn etwas schiefgeht:

```bash
cmux browser console list
cmux browser screenshot --out /tmp/cmux-failure.png
```

Die Browser-Surface importiert außerdem Cookies, Verlauf und Sessions aus Chrome, Firefox, Arc und 20+ weiteren Browsern – Panes starten also authentifiziert statt ausgeloggt. Die Automatisierungs-Surface (wait, eval, get, find, console, screenshot, Dialog-Handling, Tab-Management) wurde aus `vercel-labs/agent-browser` portiert. Wenn du Web-Apps mit einem Agent baust, ist das ziemlich überzeugend. Der Browser hört auf, ein separates Ding zu sein, zu dem du alt-tabbst.

### Alles über die cmux-CLI steuern

Die CLI plus ein Unix-Socket bilden eine programmierbare Control Plane für die App. Das ist das „Zen of cmux"-Framing: Bausteine statt vorgeschriebenem Workflow.

Du kannst Workspaces und Fenster erstellen, Panes splitten, Terminal- oder Browser-Surfaces anlegen, Text oder Tasten in ein Terminal senden, den sichtbaren Screen oder Scrollback lesen, Tabs verschieben und umsortieren sowie Sidebar-Status, -Fortschritt und -Logs setzen. Zwei Dinge solltest du wissen:

- cmux setzt `CMUX_WORKSPACE_ID` und `CMUX_SURFACE_ID` in jedem Terminal, das es öffnet – Skripte wissen also, wo sie leben
- `~/.config/cmux/cmux.json` steuert cmux selbst (Sidebar, Tabs, Splits, Custom Commands) und greift live ohne Restart; `~/.config/ghostty/config` steuert weiterhin das Terminal-Rendering

```bash
cmux set-status build "compiling" --icon hammer --color "#ff9500" --priority 80
cmux set-progress 0.5 --label "Building..."
cmux log --level success -- "All 42 tests passed"
```

**Socket-Zugriffsmodi**

Der Control-Socket liegt unter `/tmp/cmux.sock` (Release), und sein Standard-Zugriffsmodus ist **nur cmux-Prozesse**. Skripte außerhalb von cmux-Terminals können sich nicht verbinden, es sei denn, du setzt `CMUX_SOCKET_MODE=allowAll` in der Umgebung. Die komplette Fehler-Tabelle findest du unter „Typische Setup-Probleme und Fixes".

## Die wichtigsten cmux-Befehle zuerst

Die komplette Hilfe ist breit gefächert. Das sind die Befehle, die ich zuerst lernen würde.

| Aufgabe | Befehl |
|------|---------|
| Neuen Workspace öffnen | `cmux new-workspace` |
| Aktuelles Layout splitten | `cmux new-split right` oder `cmux new-split down` |
| Neue Terminal-/Browser-Surface hinzufügen | `cmux new-surface --type terminal` oder `cmux new-surface --type browser` |
| Aktuelles Layout inspizieren | `cmux tree --all` |
| Eingabe an ein Terminal senden | `cmux send "npm run dev"` |
| Terminal-Ausgabe lesen | `cmux read-screen --scrollback --lines 200` |
| Benachrichtigung auslösen | `cmux notify --title "Build Complete" --body "All tests passed"` |
| Browser-Seite öffnen | `cmux browser open https://localhost:4321` |
| Browser-Zustand snapshotten | `cmux browser snapshot --interactive` |
| Agent-Hooks und Resume einrichten | `cmux hooks setup` |
| Remote-Workspace über SSH öffnen | `cmux ssh user@remote` |
| Remote-tmux-Sessions listen/attachen (Beta) | `cmux ssh-tmux user@remote list` |
| Resume-Status einer Surface anzeigen | `cmux surface resume show` |
| Socket-Methoden und Zugriffsmodus listen | `cmux capabilities --json` |

Zwei Details für saubere Skripte: `cmux tree` ist ein Alias von `surface ls`, und `cmux new-surface` ist eine Legacy-Fassade. Nutze in neuen Skripten die `surface`-Befehlsgruppe.

```bash
# Keep the app current
brew upgrade --cask cmux

# One-shot agent hook setup (run after installing agent CLIs)
cmux hooks setup
cmux hooks setup codex      # or per-agent
```

Wenn du dich mit Terminal-Scripting auskennst, wird cmux mit `send`, `send-key`, `read-screen`, `notify` und `browser snapshot` schnell interessant.

## cmux vs. tmux vs. Ghostty

Die Frage cmux vs. tmux ist eigentlich eine Frage, wo du arbeitest, und die Frage cmux vs. Ghostty dreht sich darum, was dein Terminal kontrollieren soll. Hier die praktische Aufteilung.

| Tool | Am besten für | Was es gut kann | Worauf achten |
|------|----------|-------------------|-------------------|
| **Ghostty** | Schneller Terminal-Alltag | Natives Gefühl, GPU-Rendering, einfache Config, eingebautes Multiplexing | Weniger Meinung zu Agent-Workflows |
| **tmux** | Portable Sessions und Remote-Arbeit | Detach/Attach auf jedem OS, SSH-freundlich, riesiges Ökosystem | Mehr Setup, mehr Keybindings, kein eingebauter Browser oder GUI-Notifications |
| **cmux** | Lokale Multi-Agent-Entwicklung unter macOS | Workspaces, Pane-Notifications, Browser-Automatisierung, CLI-Kontrolle, Agent-Session-Resume | Nur-macOS-Terminal-App; beliebiger Prozess-Zustand wird nicht checkpointet; Remote-tmux-Attach ist Beta |

Mein Fazit: Wenn du vor allem ein besseres Terminal willst, starte mit dem [Ghostty-Terminal-Setup-Guide](/de/ghostty-terminal/). Wenn du auf Remote-Servern lebst und Detach/Attach von jedem OS willst, bleibt tmux seine Miete wert – mein Post [tmux-Grundlagen für Einsteiger](/tmux-basics/) deckt diesen Workflow ab. Wenn dein Tag zu „drei Claude-Sessions, eine Codex-Session, ein Dev-Server und ein Browser, den du skripten willst" wird, ergibt cmux plötzlich viel Sinn.

Ein Plattform-Hinweis: tmux läuft überall, und mein [WezTerm-Mac-Setup-Guide](/install-wezterm-mac/) behandelt ein plattformübergreifendes GPU-Terminal – die cmux-Terminal-App dagegen läuft nur unter macOS 14+. Zwei weitere Blickwinkel auf das Multiplexer-Problem: Der [Rex Terminal Multiplexer](/de/superlogical-rex/) ist die eigene Lösung von Ghostty-Schöpfer Mitchell Hashimoto, und mein [Terminal-Multiplexer-Vergleich für 2026](/de/beste-terminal-multiplexer/) deckt das breitere Feld ab.

## cmux unter macOS installieren

### Voraussetzungen

Was schon existieren muss, bevor du anfängst:

- macOS 14.0 oder neuer

- Apple-Silicon- oder Intel-Mac

- Homebrew, wenn du den Cask-Installationsweg willst

- Eine Agent-CLI (Claude Code, Codex, OpenCode, ...), wenn du Hooks und Session-Resume willst

Die iOS-Begleit-App existiert, ist aber eine Beta mit Early Access an den Pro-Plan gebunden. Nichts in diesem Guide braucht sie.

### Die App installieren (Homebrew oder DMG)

### Homebrew

```bash
brew tap manaflow-ai/cmux
brew install --cask cmux
```

Später updatest du mit `brew upgrade --cask cmux`. Shell-Completions für zsh, bash und fish kommen mit dem Cask.

### DMG

Lade das DMG von [cmux.com](https://cmux.com/) herunter, zieh es in den Programme-Ordner und lass es über Sparkle automatisch aktualisieren. Wenn deine Shell die Completions nicht übernimmt, führe `eval "$(cmux completion zsh)"` (oder das bash/fish-Äquivalent) aus deiner Shell-Config aus.

**Gatekeeper beim ersten Start**

macOS warnt eventuell, dass die App von einem nicht identifizierten Entwickler stammt. Laut README klickst du auf Öffnen. Lade nur von cmux.com oder über den Homebrew-Tap.

### Die cmux-CLI in den PATH bringen

Innerhalb von cmux-Terminals funktioniert die CLI automatisch, weil cmux `CMUX_WORKSPACE_ID` und `CMUX_SURFACE_ID` für dich setzt. Für die Nutzung außerhalb der App gibt es zwei Wege, sie zu verlinken.

### Befehlspalette (empfohlen)

Öffne die Befehlspalette (⌘⇧P) in cmux und führe **„Shell Command: Install 'cmux' in PATH"** aus. Sie verlinkt nach `/usr/local/bin` und fragt bei Bedarf ein Admin-Passwort ab.

### Manueller Symlink (Fallback)

```bash
sudo ln -sf "/Applications/cmux.app/Contents/Resources/bin/cmux" /usr/local/bin/cmux
```

Nach beiden Methoden sollte das aus jeder Shell funktionieren:

```bash
cmux list-workspaces
cmux current-workspace
cmux notify --title "Build Complete" --body "Your build finished"
```

### Installation verifizieren

Mach das, bevor du irgendetwas anderes verdrahtest. Es dauert 30 Sekunden und fängt die meisten Setup-Probleme früh ab.

- cmux ping läuft fehlerfrei durch – die App läuft also und der Socket antwortet

- cmux identify zeigt das fokussierte Fenster, Workspace, Pane und Surface

- cmux list-workspaces --json gibt strukturierte Ausgabe aus

- cmux capabilities --json listet die Socket-Methoden und den aktuellen Zugriffsmodus

- Visueller Check: Sidebar links, ein Workspace offen, Ghostty-betriebenes Terminal bereit

Wenn `cmux ping` fehlschlägt, läuft die App nicht oder die CLI ist nicht im PATH. Gibt es einen Access-Fehler, lies den nächsten Abschnitt.

### Typische Setup-Probleme und Fixes

**Die häufigste Support-Frage: Socket-Zugriffsmodus**

Wenn `cmux`-Befehle innerhalb von cmux-Terminals funktionieren, aber aus deiner eigenen Shell oder deinen Skripten fehlschlagen, ist der Socket-Zugriffsmodus die Ursache – nicht dein Skript.

| Problem | Was los ist | Fix |
|---------|------------------|-----|
| CLI funktioniert in cmux, schlägt außerhalb fehl | Socket `/tmp/cmux.sock` steht standardmäßig auf `cmuxOnly`-Zugriff | Führe Skripte aus einem cmux-Terminal aus oder setze `CMUX_SOCKET_MODE=allowAll` in der Umgebung (nur Env). Auf geteilten Maschinen `off` oder `cmuxOnly` belassen. Verwandte Variablen: `CMUX_SOCKET_PATH`, `CMUX_SOCKET_ENABLE` |
| Socket-Skript nach einem Update kaputt | JSON-Protokoll geändert; Legacy-``-Payloads werden abgelehnt | Sende Requests in der Form `` |
| macOS meldet „App von einem nicht identifizierten Entwickler" | Gatekeeper beim ersten Start | Auf Öffnen klicken und nur von cmux.com oder dem Homebrew-Tap installieren |
| `cmux hooks setup` tat nichts | Es lief, bevor die Agent-CLI installiert war – nichts war also im PATH | Erst den Agent installieren, dann `cmux hooks setup` erneut ausführen |
| Etwas verhält sich nach einem Update seltsam | Nightly-Builds kommen schnell; Versionsdrift ist real | `cmux version` gegen das offizielle Changelog prüfen |

## cmux-Preise: Ist cmux kostenlos?

Ja, der Teil, der die meisten Leser interessiert, ist kostenlos. Das macOS-Terminal, lokale Agents mit deinen eigenen API-Keys, Browser-Panes, die Socket-API, Skills und die lokale Session-History bleiben für immer kostenlos. Bezahlte Tiers kaufen Cloud-VMs (persistente Linux-Sandboxen für Agents), die iOS-App, größere VM-Pools und Enterprise-Kontrollen.

| Plan | Preis | Was dazukommt |
|------|-------|--------------|
| **Free** | 0 $ | Volles macOS-Terminal, lokale Agents mit eigenen Keys, Browser-Panes, Socket-API, Skills, lokale Session-History |
| **Plus** | 15 $/Monat | 1 gespeicherte Cloud-VM (2–8 vCPU, 4–16 GiB RAM, 16–128 GiB Disk) |
| **Pro** | 50 $/Monat (40 $/Monat jährlich) | Bis zu 5 Cloud-VMs mit geteilten 20 vCPU / 40 GB RAM, unbegrenzte Workspaces, iOS-App, E-Mail-Support |
| **Max** | 200 $/Monat (160 $/Monat jährlich) | 5 Cloud-VMs mit geteilten 80 vCPU / 160 GB RAM; schaltet bis zu 64-GB-/32-vCPU-VMs frei |
| **Team** | 60 $/Nutzer/Monat | Pro-Features pro Seat, zentrale Abrechnung, Priority-Support |
| **Enterprise** | Individuell | Self-hosted/Air-gapped-Cloud-Ausführung, SSO/SAML, Audit-Logs, SOC 2 + SLA |

Cloud-VMs ziehen aus einem einzigen gemeinsamen vCPU/RAM-Pool pro Plan; pausierte VMs verbrauchen den Pool nicht. Der Plus-Plan steht auf der Pricing-Seite (Stand: November 2026). Alle Details gibt es auf [cmux.com/pricing](https://cmux.com/pricing).

**Die bitdoze-Kostenzeile**

Alles in diesem Guide läuft im Free-Tier für 0 $ im Monat. Du zahlst nur, wenn du Agents auf Remote-VMs statt auf deinem Mac laufen lassen willst.

Lizenz-Recap für Kostenbewusste: Die Core-App ist GPL-3.0-or-later (lokal frei nutzbar), während die serverseitigen Teile unter BUSL-1.1 stehen und für produktives Self-hosting eine kommerzielle Lizenz brauchen. Für Solo-Betreiber, die Agents auf einem Mac fahren, reicht das Free-Tier.

## Session-Restore und Agent-Resume

Das ist die größte Verhaltensänderung, seit ich im März 2026 erstmals über cmux geschrieben habe – und sie behebt den alten „Restart verliert deine Arbeit"-Vorbehalt.

Beim Neustart stellt cmux Layout, Metadaten, Scrollback und Browser-Verlauf wieder her. Bei unterstützten Agents geht es weiter: Hooks erfassen native Resume-Tokens, sodass Agent-Sessions dort zurückkommen, wo du aufgehört hast. Die Docs listen 15+ Agents mit Resume-Support, darunter Claude Code (`claude --resume `), Codex, OpenCode, Gemini, Amp, Cursor CLI, Copilot, Pi und mehr. Die [Session-Restore-Docs](https://cmux.com/docs/session-restore) führen die aktuelle Matrix.

```bash
cmux hooks setup                # install all agent integrations found on PATH
cmux surface resume show        # inspect resume state for the current surface
cmux restore-session            # restore a previous session
```

Wenn du das alte Verhalten willst, deaktiviere es in `~/.config/cmux/cmux.json`:

```json
{
  "terminal": {
    "autoResumeAgentSessions": false
  }
}
```

**Resume-Sicherheit**

Sensible Umgebungs-Keys (Tokens, Passwörter, API-Keys) werden entfernt, bevor ein Resume-Binding gespeichert wird, und nur „trusted" Bindings laufen beim Restore automatisch. Gut zu wissen, bevor du das auf eine Maschine mit Produktiv-Credentials in Env-Vars loslässt.

Zwei Limits solltest du im Kopf behalten. Erstens checkpointet cmux keinen beliebigen Prozess-Speicher: tmux, vim und schlichte Shells öffnen sich als normale Terminals wieder. Zweitens behauptet die Homepage, der Zustand überlebe einen kompletten Rechner-Neustart; die Docs formulieren es konservativer (Restore beim App-Neustart, Agent-Resume, wenn Hooks ein Token erfasst haben). Ich würde der Docs-Formulierung trauen, bis du einen vollen Reboot selbst verifiziert hast.

## Beispiel-Workflow: Claude Code + Browser + Benachrichtigungen

So sieht das Setup aus, für das cmux gebaut scheint. Halte das Layout langweilig:

- Ein Workspace für den Haupt-Coding-Agent

- Ein Split für Logs oder Tests

- Eine Browser-Surface für die App, die du baust

- Benachrichtigungen in Agent-Hooks verdrahtet

**Verdrahte zuerst die Hooks.** Früher musstest du ein Claude-Code-Hook-Skript per Hand schreiben, das bei Stop-Events `cmux notify` aufrief. Heute erledigt das ein Befehl – nachdem die Agent-CLI installiert ist, damit ihre Binary im PATH liegt:

```bash
cmux hooks setup
```

**Dann skripte den Loop**, wenn er wiederholbar sein soll:

```bash
# Workspace for the project
cmux new-workspace --cwd ~/projects/my-app

# Split for logs
cmux new-split down

# Open the app in a browser surface
cmux browser open https://localhost:4321
cmux browser fill "#email" --text "me@example.com"
cmux browser click "button[type='submit']" --snapshot-after
cmux browser wait --text "Welcome" --timeout-ms 10000

# Notify yourself when the task is done
cmux notify --title "Claude Code" --body "Agent finished the refactor"
```

Die Schritte `--snapshot-after` und `wait` sind der Verify-Teil des Loops: Wenn `wait` in einen Timeout läuft, ist etwas kaputt. Sichere Beweise, bevor du debuggst:

```bash
cmux browser console list
cmux browser screenshot --out /tmp/cmux-failure.png
```

Das ist wenig Verdrahtung, aber genau die Art Ding, das eine App von „interessante Demo" zu „tatsächlich nützlich an einem Dienstag" macht. Wenn du in diesen Terminals ein saubereres Prompt willst, ist der [Starship-+-Ghostty-Terminal-Guide](/de/starship-ghostty-terminal/) eine gute Ergänzung.

## Was sich 2026 in cmux geändert hat

cmux ging in etwa acht Monaten von frühen 0.2x-Builds auf 0.65.2.2 (Changelog, 27.10.2026). Die Kurzliste dessen, was seit März gelandet ist:

- Agent-Session-Resume und `cmux hooks setup` (15+ Agents mit nativen Resume-Tokens)
- SSH-Workspaces (`cmux ssh`, Browser-Panes routen durch das Remote-Netzwerk) und `cmux ssh-tmux` List/Attach (Beta)
- Skills, wiederverwendbare Agent-Workflows mit öffentlicher Sammlung in `manaflow-ai/cmux-skills`
- Cloud-VMs und die Preis-Tiers; eine iOS-Begleit-App in Beta (Early Access an Pro gebunden)
- OSC-7501-Program-Status (idle/working/blocked/done/error) in der Sidebar
- Globale Session-Suche (⌘⌥F) und Tastatur-Navigation (⌃⌘E Sidebar, ⌃⌘1-9 Panes, ⌘⇧B letzter Prompt-Pane)
- Browser-Automatisierungs-Ausbau: wait, eval, get, find, console, screenshot, Dialoge, Cookies, plus Import aus 20+ Browsern
- Sidebar-Metadata-CLI mit verlinktem PR-Status für Agent- und CI-Hooks

Ehrlicher Vorbehalt: 7.084 offene Issues im Repo (Stand: 16.11.2026). Das Tempo ist hoch und der Backlog real. Setze deine Erwartungen am Changelog fest, nicht am Issue-Tracker.

## Was mir an cmux gefällt

Es versucht nicht, das Terminal zu verstecken. Viele Agent-Tools beeilen sich, eine komplett neue Umgebung um das LLM herum zu bauen. cmux fühlt sich immer noch so an, als hätte es ein Terminal-Mensch gemacht.

Dass der Browser Teil desselben Workspaces ist, ist eine größere Sache, als es auf dem Papier aussieht. Wenn Terminal, Browser und Benachrichtigungen zusammenleben, fühlt sich der Workflow enger an.

Das Projekt ist ehrlich damit, ein Satz von Bausteinen zu sein. Der [Zen of cmux](https://cmux.com/blog/zen-of-cmux)-Post sagt es direkt: cmux ist nicht präskriptiv, und der Workflow gehört dir zum Formen. Diese Haltung gefällt mir – und nach einem Jahr „KI-Betriebssystem"-Pitches liest sie sich immer noch als die richtige Entscheidung.

## Was du vor dem Wechsel wissen solltest

cmux ist vielversprechend, aber keine Magie.

- Die Terminal-App ist **nur macOS** (macOS 14+). Die iOS-Begleit-App ist eine Pro-gated Beta, und Linux existiert nur als bezahlte Cloud-VMs.
- Agent-Sessions resumen via Hooks; **beliebiger Prozess-Zustand wird weiterhin nicht checkpointet**. tmux, vim und schlichte Shells öffnen sich als normale Terminals wieder.
- Remote-tmux-Attach (`cmux ssh-tmux`) ist **Beta**. Für portables Detach/Attach auf jedem OS bleibt tmux auf dem Remote-Host das einfachere Werkzeug.
- Serverseitige Teile stehen unter **BUSL-1.1**. Für lokale Nutzung egal, relevant, wenn du die Infrastruktur selbst hosten willst.
- Das Projekt bewegt sich schnell mit ~7k offenen Issues. Teste Upgrades, bevor du dich auf ein bestimmtes Verhalten verlässt.
- Wenn du keine Browser-Automatisierung oder Agent-Notifications brauchst, **reicht Ghostty allein vielleicht schon**.

Nichts davon ist Kritik an cmux. Es heißt nur: Setze es für den Job ein, den es klar lösen will.

## FAQ

**Ist cmux nur Ghostty mit Tabs?**

Nein. cmux nutzt `libghostty` fürs Rendering, ist aber eine separate native macOS-App mit Fokus auf Workspaces, Notifications, Browser-Surfaces und Automatisierung für Agent-Workflows.

**Ist cmux kostenlos?**

Ja für den lokalen Workflow: Das macOS-Terminal, lokale Agents mit eigenen API-Keys, Browser-Panes und die CLI/Socket-API bleiben für immer kostenlos. Bezahlte Pläne (ab 15 $/Monat) kaufen Cloud-VMs, die iOS-App und Enterprise-Kontrollen. Die komplette Tabelle steht im Preis-Abschnitt oben.

**Brauchst du tmux noch, wenn du cmux nutzt?**

Für portables Detach/Attach auf Remote-Maschinen und Nicht-Mac-Hosts: ja, tmux löst dieses Problem weiterhin besser. cmux kann SSH-Workspaces öffnen und Remote-tmux-Sessions attachen (Beta), aber tmux bleibt der sicherere plattformübergreifende Standard für reines Remote-Session-Management.

**Stellt cmux Sessions wieder her?**

Layout, Metadaten, Scrollback und Browser-Verlauf werden beim Neustart wiederhergestellt. Agent-Sessions (Claude Code, Codex, OpenCode und 15+ weitere) resumen, wenn Hooks ein natives Resume-Token erfasst haben. Beliebige Prozesse wie tmux oder vim öffnen sich als normale Terminals wieder – ihr Speicher wird nicht checkpointet.

**Welche Agents funktionieren mit cmux?**

Jeder Agent, der in einem Terminal läuft, funktioniert. Die offizielle Liste umfasst Claude Code, Codex, OpenCode, Gemini CLI, Amp, Cursor CLI, Copilot, Aider, Goose, Cline, Kiro, Pi und mehr – 15+ davon mit nativem Resume-Support. Um Agents für diese Panes zu finden: [OpenCode](https://go.bitdoze.com/opencode-go) fährt günstige Coding-Modelle, und [Factory-Droid-CLI-Agents](https://go.bitdoze.com/droid-cli) decken Planungs- bis Coding-Aufgaben über den Software-Lebenszyklus ab.

**Funktioniert cmux über SSH?**

Ja. `cmux ssh user@remote` öffnet einen Workspace für eine Remote-Maschine, Browser-Panes routen durch das Remote-Netzwerk, sodass `localhost` funktioniert, und `cmux ssh-tmux` listet und attached Remote-tmux-Sessions (Beta). Für reines plattformübergreifendes Detach/Attach bleibt tmux auf dem Remote-Host das einfachere Werkzeug.

## Fazit

cmux fühlt sich an wie ein Werkzeug von jemandem, der es satt hatte, KI-Agents in generischen Terminals zu jonglieren, und beschloss, das Problem richtig zu lösen. Ich würde es nicht jedem Terminal-Nutzer empfehlen. Aber wenn dein lokaler Workflow schon aus mehreren Agent-Sessions, App-Previews und ständigem Kontextwechsel besteht, ist es aktuell eine der schärferen Optionen.

Die Kurzfassung für den Betrieb: Installiere es, bestätige `cmux ping`, führe `cmux hooks setup` aus und zahl nichts, bis du Agents auf Remote-VMs willst. Die Docs übernehmen ab da.

[Mit cmux loslegen](https://cmux.com/docs/getting-started)