cmux bets the terminal, not the orchestrator, is where AI agents belong

Manaflow has released cmux, an open-source, GPL-licensed macOS terminal built on libghostty that treats running AI coding agents as the primary job of a terminal, not a side effect. The pitch is narrow and specific: vertical tabs in a sidebar, notification rings on panes, a scriptable in-app browser, and a CLI and socket API for automating all of it. It is a terminal for people who keep six Claude Code and Codex sessions open at once and lose track of which one is waiting on them.

The most interesting thing about cmux is what it refuses to be. It is not an orchestrator. It is not a GUI that models your agents as tasks in a queue. It is a terminal with a browser, splits, tabs, and a command line, and the rest is left to the developer. That is a real editorial position in a market that has been sprinting the other way.

The notification problem is the actual product

Read the author’s own rationale and the pain point is concrete. Claude Code’s notification body is always the string “Claude is waiting for your input,” with no context. Open enough tabs and the titles stop being readable. So you miss the moment an agent needs you, and a parallel workflow collapses back into serial waiting.

cmux’s fix is mechanical, not clever. It picks up terminal sequences (OSC 9, 99, and 777), and it ships a cmux notify CLI you can wire into agent hooks for Claude Code, OpenCode, and others. When an agent is waiting, its pane gets a blue ring and its sidebar tab lights up. Cmd+Shift+U jumps to the most recent unread. A notification panel collects everything pending in one place.

That is a small feature set. It is also the whole reason the app exists, and it tells you something about where agent tooling is stuck. The bottleneck for a developer running many agents is not model quality or token throughput. It is attention routing. The agent finishes, and you do not know. Everything downstream of that is wasted wall-clock time.

The sidebar is a quiet dashboard

The vertical tab sidebar carries git branch, linked PR status and number, working directory, listening ports, and the latest notification text for each workspace. That is a lot of ambient state packed into a strip of screen real estate, and it is the correct place for it. A terminal that knows which branch and which PR a pane is attached to is a terminal that understands the unit of work is not the shell session. It is the task.

The in-app browser is the second real addition. It splits a browser pane next to the terminal and exposes a scriptable API ported from agent-browser. Agents can snapshot the accessibility tree, grab element refs, click, fill forms, and evaluate JavaScript. So Claude Code can drive your local dev server without leaving the window. That is the kind of integration that sounds minor until you have watched an agent flail against a headless browser it cannot see.

Native, not Electron, and that is a claim worth testing

cmux is built in Swift and AppKit, not Electron or Tauri. It uses libghostty for GPU-accelerated rendering and reads your existing ~/.config/ghostty/config for themes, fonts, and colors. The author says the performance of existing coding orchestrators, most of them Electron or Tauri apps, was a motivating annoyance.

This is the part of the pitch that is easiest to verify and hardest to fake. A native macOS terminal that inherits a Ghostty config has a low switching cost for anyone already on Ghostty, which is a meaningful slice of the terminal-enthusiast population. Whether the native claim holds up under a dozen panes and a browser split is an empirical question, and the answer is not in the README.

There is also a real cost to the ambition. The README documents shell watcher churn and managed-Mac process audit volume, and points to a CMUX_NO_GIT_WATCH=1 mitigation with trade-offs against Git and PR updates. A terminal that polls git state and PR status for every workspace is doing continuous background work, and on a managed corporate Mac that shows up in process audits. That is the tax on the ambient dashboard, and it is the kind of thing that only surfaces after you ship.

The orchestration debate cmux is sidestepping

The “Zen of cmux” section is the most quotable part of the repo, and it is a direct shot at the closed orchestrator category. The argument: nobody has figured out the best way to work with agents, the teams building closed products have not either, and a million developers with composable primitives will find efficient workflows faster than any product team designing top-down.

That is a bet on emergence over design. It is also, frankly, the same bet that has been wrong as often as it has been right in developer tooling. Primitives win when the workflow is genuinely unknown and heterogeneous. They lose when the workflow converges and people want the opinionated path. Right now, agent workflows look unknown and heterogeneous, which favors cmux’s position. Ask again in a year.

What cmux gets right is the interface layer. It does not try to own your agent runtime. It hooks into Claude Code, Codex, Grok, OpenCode, Pi, Amp, Cursor CLI, Gemini, Rovo Dev, Copilot, CodeBuddy, Factory, and Qoder for session resume, and it stays out of the way otherwise. The cmux claude-teams command runs Claude Code’s teammate mode with teammates spawning as native splits, no tmux required. That is a terminal being a good citizen of an ecosystem it does not control.

What this means for AI builders

The signal here is not that cmux is the terminal you should switch to. It is that the agent-tooling stack is developing a real interface layer, and it is being built in the open by people who run agents all day rather than by platform teams at the labs.

Watch two things. First, whether the notification and sidebar primitives get adopted as a convention, because a cmux notify hook is the kind of thing that becomes more valuable the more tools speak it. Second, whether the native-performance claim survives contact with real parallel workloads, because that is the difference between a clever side project and a daily driver.

The agents got good enough to run in parallel. The tooling to keep track of them is still being written, and cmux is one of the more honest attempts at it.