Bitdoze-Logo

cmux Terminal: Praxis-Guide für KI-Coding-Agents unter macOS

Lerne cmux Terminal unter macOS: installieren, KI-Coding-Agents in Workspaces betreiben, den Browser automatisieren, Benachrichtigungen verdrahten – und cmux vs. tmux und Ghostty.

Dragos

Aktualisiert Veröffentlicht 22 Min. Lesezeit

cmux Terminal unter macOS mit KI-Agent-Workspaces, Split-Panes und einer eingebauten Browser-Surface

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 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

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 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 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

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 an. Wenn du den reinen Multiplexer-Ansatz ohne GUI willst, behandelt mein Herdr-Agent-Multiplexer-Review 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

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. Für OpenCode-Nutzer hilft mein OpenCode-vs-Pi-Agent-Vergleich 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 "[email protected]"
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. 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 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 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 ist die eigene Lösung von Ghostty-Schöpfer Mitchell Hashimoto, und mein Terminal-Multiplexer-Vergleich für 2026 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 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-{"command": "..."}-Payloads werden abgelehnt Sende Requests in der Form {"id", "method", "params"}
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.

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 <id>), Codex, OpenCode, Gemini, Amp, Cursor CLI, Copilot, Pi und mehr. Die Session-Restore-Docs 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 "[email protected]"
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 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-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 fährt günstige Coding-Modelle, und Factory-Droid-CLI-Agents 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
#Ghostty#Cmux#tmux

Hat diese Anleitung bei dir funktioniert?

Brauchst du Hilfe bei Astro, VPS oder einer Self-hosted-App? Services ansehen →