cmux - macOS Terminal for AI Coding Agents

cmux is a macOS terminal project from manaflow-ai that presents itself as a Ghostty-based terminal with vertical tabs and notifications for AI coding agents. The repository README frames the tool around a practical problem that has become familiar to developers experimenting with Claude Code, Codex, and similar agent workflows: once several agent sessions are running at the same time, it becomes hard to know which pane needs attention, which project is active, and where the useful context lives.

The project is explicitly terminal-centered rather than a full replacement environment. Its README describes a native macOS app built with Swift and AppKit, using libghostty for terminal rendering and reading an existing Ghostty configuration for themes, fonts, and colors. Around that terminal core, cmux adds workspaces, split panes, vertical tabs, notification indicators, an in-app browser, SSH-oriented workflows, and scriptable control through CLI and socket interfaces.

Why this kind of terminal matters now

AI coding agents have changed the shape of a development session. A developer may no longer have one terminal, one editor, and one server log. Instead, the workflow can involve multiple agent prompts, local dev servers, background tasks, review panes, browser sessions, and remote machines. The friction is not only compute or model quality; it is coordination.

cmux addresses that coordination layer from the terminal side. Its thesis is that developers may want more structure than plain split panes, but less prescription than a complete agent orchestration product. That is a sensible middle ground. Many engineers already have terminal muscle memory, dotfiles, shell workflows, and project conventions. A tool that keeps the terminal as the primary surface while adding AI-agent-aware notification and navigation cues can feel less disruptive than moving every task into a new dashboard.

The README also positions cmux as a response to notification ambiguity. Generic macOS notifications can tell a user that an agent is waiting, but not necessarily which workspace, branch, pane, or task matters. cmux tries to make that state visible directly in the interface.

What the repository says it can do

The feature list in the README centers on attention management, workspace metadata, and scriptable surfaces. The described capabilities include notification rings that highlight panes when coding agents need input, a notification panel for pending items, and tabs that light up when attention is required.

Other notable pieces include:

Vertical and horizontal tabs, with sidebar metadata such as git branch, linked pull request information, working directory, listening ports, and recent notification text.
An in-app browser that can sit beside a terminal pane and expose scriptable browser actions.
SSH workspaces created through cmux ssh, with browser panes routing through the remote network.
A Claude Code Teams entry point described as spawning teammates as native splits with sidebar metadata and notifications.
Browser import for cookies, history, and sessions from several browsers, so browser panes can begin authenticated.
Custom commands through project configuration.
CLI and socket API access for creating workspaces, splitting panes, sending keystrokes, and automating browser actions.

The project also states that it is a native macOS application rather than an Electron app, that it is Ghostty-compatible, and that terminal rendering is GPU-accelerated via libghostty. Those are implementation claims from the repository, not independent benchmark conclusions.

Who is most likely to benefit

cmux is aimed at developers who already live in terminals and are actively experimenting with AI coding agents. It is especially relevant for people who run several Claude Code, Codex, OpenCode, or similar sessions in parallel and need a better way to track which one is waiting, what it is attached to, and where the related project context sits.

It may also fit developers who prefer building their own workflows from composable primitives. The READMEâs âZen of cmuxâ section is clear about this philosophy: cmux is framed as a terminal, browser, notification system, workspace manager, split-pane environment, and CLI-controlled primitive rather than a prescriptive end-to-end solution. That makes it more interesting for power users than for teams looking for a locked-down, standardized agent workflow.

The strongest fit is probably a macOS developer who values native application performance, uses or likes Ghostty-style terminal configuration, and wants agent sessions to stay close to normal development habits. A developer who mostly works inside a web IDE or a single graphical coding assistant may not feel the same need.

Adoption notes before trying it

The README describes two installation routes: a recommended DMG download and a Homebrew cask. It also notes that cmux auto-updates via Sparkle after the DMG installation. For Homebrew users, the repository shows a tap and cask workflow rather than a generic package-manager instruction.

A practical first test would be modest. Instead of moving an entire workflow into cmux, a developer could open one real project, run one or two agent sessions, and check whether the notification rings, sidebar metadata, and split browser pane reduce context switching. The value of this class of tool is hard to judge from a feature checklist alone; it depends on whether its interface matches the way a person already manages branches, local ports, dev servers, browser auth, and agent prompts.

The projectâs browser import feature is worth treating carefully. Starting browser panes already authenticated can be convenient, but developers should be deliberate about which sessions and accounts they bring into an agent-adjacent workflow. The same applies to SSH sessions and remote workspaces: the README describes useful remote-machine behavior, but teams should still apply their normal access-control and audit expectations.

Caveats and limits

The most obvious limit is platform scope. cmux is described as a macOS app, built with Swift and AppKit. That is good news for Mac users who want a native feel, but it means the repository should not be read as a general cross-platform terminal replacement unless the project later documents broader support.

A second caveat is workflow maturity. AI coding-agent practices are still evolving quickly, and the README itself argues that nobody has fully settled the best way to work with agents. That makes cmux interesting, but it also means adoption should be experimental. Teams may need to define their own conventions for agent hooks, notification behavior, browser automation boundaries, and workspace naming.

There is also the usual open-source evaluation work to do. Before relying on cmux for production development, readers should inspect the repository, review the license and release process, test updates, understand how browser sessions are imported, and decide whether the toolâs automation surface fits their security model. The feature set is powerful precisely because it connects terminals, browsers, remote sessions, and agent hooks; that power deserves careful configuration.

Editorial verdict

cmux is one of the more focused examples of a new developer-tool category: not simply a terminal, not simply an AI coding UI, and not exactly a multiplexer in the old sense. It treats AI agents as noisy, parallel collaborators that need visible state, routing, and attention cues, while keeping the developer close to the terminal.

The editorial appeal is its restraint. cmux does not claim to solve the entire software-development process. It offers primitives: panes, tabs, workspaces, notifications, browser surfaces, SSH support, custom commands, and scriptable control. For developers who want to compose their own AI coding environment, that is likely more attractive than a heavily opinionated assistant interface.

The trade-off is that cmux will be most useful to people who already know why they need it. If your agent usage is occasional, a normal terminal plus your editor may be enough. If you routinely supervise multiple coding agents and want better visibility into their state, cmux is worth a closer look.