cmux: The Terminal Built for AI Coding Agents

#cmux #terminal #aiagents #tmux

https://www.youtube.com/watch?v=RhCHVg8klD4

You're running eight coding agents at once. One just finished a refactor. Another hit an error three minutes ago. A third is waiting for your input. But you're staring at a wall of tmux panes, and they all look exactly the same.

Control-B, N. Control-B, N. Control-B, N. Cycling through, hoping you'll notice which one needs you. This is how most developers run agents today — blind, no status, no notifications, just guessing. And the more agents you run, the worse it gets.

What if the terminal itself could tell you?

What cmux Actually Is

cmux is not a tmux plugin. Not a wrapper. Not a configuration hack. It's a completely new terminal emulator, built from scratch for macOS.

Under the hood, it uses libghostty, the same rendering engine that powers Ghostty. So you get GPU-accelerated rendering, proper font shaping, and native macOS integration. But the real difference isn't the rendering — it's that cmux was designed from day one to understand what your agents are doing.

It's built by Manaflow, a two-person Y Combinator startup. In just two months, it hit 10,000 stars on GitHub. Mitchell Hashimoto, the creator of Ghostty, called it "a huge success story for libghostty."

Notification Rings — The Killer Feature

Every pane in cmux has a colored border that tells you its status at a glance:

Blue — the agent needs your attention
Green — completed successfully
Yellow — waiting
Red — something went wrong

Now imagine your screen with eight panes. Six have no ring — they're working. One glows green — done. One pulses red — error. You know exactly where to look. Instantly. No cycling. No guessing.

And Cmd+Shift+U jumps you straight to the newest unread pane, across all your workspaces. It works like unread messages in a chat app, but for your terminal.

Setting a notification is one CLI call:

cmux notify --color red --message "Build failed"

Built-in Browser

cmux has a browser built in. Not a tab that opens Chrome — an actual WebKit browser panel, right next to your terminal.

Your agent can navigate to a page, click elements, inspect the DOM, fill out forms. No Playwright. No browser MCP server. No headless Chrome running in the background.

The insight is simple but powerful: the browser needs to be inside the session, not adjacent to it. When the browser lives in the same context as the agent, the agent can see what it's browsing and act on it — all in one place.

Agent Spawns Agent

This is where it gets interesting. In cmux, an agent can spawn another agent.

Your primary agent runs cmux new-split right, and a fresh terminal pane appears. Then it runs cmux send to type a command into that pane. And cmux read-screen to monitor the output.

# Primary agent creates a helper pane
cmux new-split right

# Send a command to the new pane
cmux send "npm run test"

# Read what's happening in that pane
cmux read-screen

The first agent is now orchestrating the second. No external tooling. No message queues. No API calls. Just terminal primitives. Multi-agent orchestration, happening right inside your terminal.

The CLI API

All of this is powered by a clean CLI API. cmux exposes composable primitives — everything communicates through a Unix socket:

cmux workspace new           # Create a new workspace
cmux split right             # Split the current pane
cmux notify --color green --message "Done"  # Set notification ring
cmux progress set 75         # Display a progress bar

These aren't hacks bolted on. They're first-class features. And because it's all CLI, any agent that can run shell commands can orchestrate cmux — Claude Code, Cursor, Codex, any of them.

The Honest Limitations

Let's be straight about what cmux can't do:

macOS only. No Linux, no Windows.
No detach/reattach. You can't SSH into a server and resume a session later. If that's your workflow, keep tmux.
Two months old. Expect rough edges. This isn't a mature, battle-tested tool.
macOS sandboxing conflicts. The sandboxing model can sometimes conflict with macOS security settings.

This is a brand new bet on where terminals are heading, not a tmux replacement for every use case.

Who Should Use It

If you're on a Mac and you regularly run three or more coding agents at the same time, cmux is worth trying. The notification rings alone save you from the blind cycling problem.

If you need server-side terminal multiplexing — keep tmux. If you need cross-platform support — keep tmux. cmux isn't trying to replace tmux everywhere. It's solving a specific problem that tmux was never designed for: multi-agent awareness, in a world where developers are running more agents every month.

GitHub: github.com/manaflow-ai/cmux