The way developers work with AI has outgrown the terminal. Most of us still bounce between a tmux session, a browser tab, a notification center, and three Claude Code panes — all duct-taped together. Cmux, an open-source macOS terminal from Manaflow, asks a sharper question: what if the terminal itself was designed for AI coding agents from the ground up?
Built on Ghostty's GPU-accelerated rendering engine and wrapped in native Swift and AppKit, cmux is a small but pointed answer. It now sits at more than 15,000 GitHub stars and has become a fixture in the toolchains of developers who run multiple coding agents at once.
Comparing it against something specific? Skip to how it compares for cmux against Ghostty, Zed, tmux, Conductor and Superset side by side.
Why a new terminal in 2026?
Terminals haven't changed much in two decades. They were designed for one user typing into one shell. Then AI coding agents arrived and broke the model: a single developer might run five Claude Code sessions, a Codex review pass, a Gemini exploration agent, and a Cursor CLI batch — all needing attention at different moments. tmux can split panes, but it cannot tell you which pane is asking for input. Ghostty renders beautifully, but it has no notion of "this agent is blocked on you."
Cmux fills that gap. It treats AI agents as first-class citizens of the terminal — visible, attention-aware, and scriptable.
What cmux does differently
The headline features are simple to describe and surprisingly effective in practice.
Vertical tabs with context. A sidebar shows each workspace's git branch, PR status, working directory, listening ports, and most recent notification. Switching between five parallel agents stops feeling like grep-ing your own brain.
Notification rings. When an agent needs input, the pane gets a blue ring and the tab lights up. Native macOS notifications follow. The ⌘⇧U shortcut jumps you to the latest unread notification — the closest thing to a "next ticket" button for AI sessions.
Split panes by default. Horizontal and vertical splits work with zero configuration. You can run Claude Code on the left, watch test output on the right, and keep a third pane open for ad-hoc shell work.
An in-app browser. This is the surprise feature. Cmux ships a scriptable browser pane that exposes accessibility-tree snapshots, element references, form filling, and JavaScript evaluation. Agents that want to verify a fix in a live preview no longer need to leave the terminal — and you can drive the browser from the CLI.
Ghostty-compatible config. Cmux reads your existing ~/.config/ghostty/config, so themes, fonts, and colors carry over. No re-tuning your setup.
The agent matrix
Cmux supports the agents that matter today, plus a hook system for the long tail:
- Claude Code (with native Teams mode integration)
- Codex
- OpenCode
- Gemini CLI
- Grok CLI
- Amp
- Cursor CLI
- Copilot
- Pi
The point is not the list — it is that cmux refuses to lock you into one vendor. The same workspace can host a Claude Code planner, a Codex reviewer, and a Gemini explorer, with notifications routed correctly to each.
A practical workflow
Here is how cmux changes a real session. Suppose you are shipping a feature that needs UI work, an API endpoint, and a test pass.
- Press ⌘N to create a new workspace pointed at your repo.
- ⌘D to split right; launch Claude Code on the API in pane A and another Claude Code session on the UI in pane B.
- ⌘⇧D to split down on the UI pane; run
npm run test --watchunderneath. - ⌘⇧L to open a browser split pointed at your local preview.
- Walk away. When the API agent finishes and needs your sign-off, the tab glows blue. ⌘⇧U jumps you straight to it.
That last step is the unlock. The old workflow involved checking each pane every few minutes. The new workflow is interrupt-driven — agents call you, not the other way around.
CLI and scripting
For teams that automate, cmux exposes a CLI and socket API. You can create workspaces, split panes, send keystrokes, and drive the in-app browser from scripts. Combined with Claude Code skills or shell hooks, this opens the door to "press one key, spin up a five-pane review layout with the right agents already running."
The composable-primitives philosophy is intentional. Cmux does not try to be Conductor or Superset, both of which prescribe opinionated multi-agent workflows. Cmux gives you the panes, the notifications, and the API, and lets you build the rest.
How it compares
If you are choosing between these rather than reading about cmux specifically, this is the section you want.
| Runs agents in parallel | Knows which agent needs you | Editor included | Platforms | |
|---|---|---|---|---|
| cmux | Yes — vertical tabs, split panes | Yes — notification rings | No | macOS only |
| Ghostty | Panes only | No | No | macOS, Linux |
| tmux | Panes only | No | No | Everywhere |
| Zed | Limited — one agent panel | No | Yes | macOS, Linux |
| Conductor | Yes — orchestration layer | Partial | No | macOS |
| Superset | Yes | Yes | Yes — full IDE | macOS |
The short version: pick cmux if you are terminal-first on macOS and run several agents at once, Superset if you want the whole IDE handed to you, Zed if the editor matters more than the terminal, and tmux if you need Linux or remote work. Detail below.
vs. Zed. Zed is an editor first, with an AI panel bolted on well. It handles one agent conversation gracefully and several poorly — there is no equivalent of cmux's notification ring telling you which of six sessions is blocked. If your day is mostly writing code with an agent assisting, Zed wins. If your day is mostly supervising agents that write the code, it does not.
vs. Ghostty. Ghostty is the rendering engine; cmux uses it. Ghostty has no vertical tabs, no notification rings, and no in-app browser. If you only run one agent at a time, Ghostty is enough.
vs. tmux. tmux is older, more scriptable in some ways, and runs everywhere. It has no notion of agent attention, no GUI affordances, and no built-in browser. tmux still wins for Linux-first or remote-first workflows.
vs. Conductor / Superset / Superconductor. Those tools bundle agent orchestration on top of the terminal. Cmux stays closer to the terminal layer. Superset adds an editor and browser as a coherent IDE; cmux gives you the primitives without forcing a workflow.
vs. VS Code with Claude Code extension. Some developers prefer one heavy IDE for everything. Cmux is for the opposite preference: terminal-first, multi-agent, multi-window.
Limitations
Cmux is macOS-only. There is no Linux or Windows port and none on the roadmap. Some early users report rough edges around pane focus and keyboard customization. The notification model is excellent when it works, but agents that do not implement the hook protocol cleanly will not light up the ring. And because cmux is GPL-3.0, commercial integrations may need to request a separate license from Manaflow.
When to adopt
Adopt cmux if you regularly run more than two AI coding sessions at once, you live in the terminal, and you are on macOS. The activation energy is low — a single brew install --cask cmux and your existing Ghostty config carries over.
Skip cmux if you prefer a single IDE window, work primarily on Linux, or only use one agent at a time. Tools like Zed or VS Code with Claude Code will fit better.
The bigger pattern
Cmux is part of a broader shift: developer tools are being rebuilt around the assumption that AI agents are workspace operators, not autocompletes. The terminal is the first surface to feel this pressure because that is where agents actually run. Expect editors, browsers, and version control to follow.
For now, if you are running Claude Code, Codex, or Gemini in parallel on a Mac, cmux is the cheapest way to feel what an agent-native workspace looks like — and the cheapest way to escape the tmux-plus-six-windows tax that most of us are still paying.