cmux: A Ghostty-Based Terminal Built for AI Coding Agents

If you run Claude Code, Codex, or OpenCode sessions in parallel, you already know the problem. You have six terminal splits open, each running an agent on a different task. One of them finishes and needs your input. macOS sends a notification that says "Claude is waiting for your input" with zero context about which session or what it wants. You Alt-Tab through splits trying to find it.

cmux solves this with a purpose-built terminal that treats AI agent sessions as first-class citizens.

What cmux Is

cmux is a native macOS app written in Swift and AppKit. It uses libghostty for terminal rendering and reads your existing ~/.config/ghostty/config for themes, fonts, and colors. If you already use Ghostty, cmux feels familiar.

The key additions over a standard terminal:

• Vertical sidebar with workspace metadata (git branch, PR status, working directory, listening ports, latest notification)
• Notification rings on panes and tabs when an agent needs attention
• In-app browser with a scriptable API
• CLI and socket API for automation
• Claude Code Teams integration (native splits, no tmux required)

Install via Homebrew:

brew tap manaflow-ai/cmux
brew install --cask cmux

Or download the DMG directly.

The Notification System

This is the core feature that makes cmux different from running agents in regular terminal splits.

When a coding agent finishes a task and needs your input, cmux detects it through terminal sequences (OSC 9/99/777) or via the cmux notify CLI command. The pane gets a blue ring overlay, and the sidebar tab lights up with notification text.

Press Cmd+Shift+U to jump to the most recent unread notification. A notification panel shows all pending notifications in one place.

You can wire notifications into agent hooks:

{
  "hooks": {
    "Stop": [{
      "matcher": "",
      "hooks": [{
        "type": "command",
        "command": "cmux notify --title 'Agent stopped' --body 'Review needed in $PWD'"
      }]
    }]
  }
}

This means every agent framework that supports hooks (Claude Code, OpenCode, Codex) can push notifications to cmux with full context about what happened.

Sidebar: More Than Tabs

The vertical sidebar shows rich metadata for each workspace:

Info	Source
Git branch	Auto-detected from working directory
PR status and number	Linked from the branch
Working directory	Current path
Listening ports	Auto-detected from processes
Latest notification	Most recent agent message

This turns the sidebar into a dashboard. At a glance you can see which agents are on which branches, which PRs they are working on, and which ones need your attention.

In-App Browser

cmux includes a browser pane that you can split alongside your terminal. The browser API is ported from Vercel's agent-browser and supports:

• Snapshotting the accessibility tree
• Getting element references
• Clicking and filling forms
• Evaluating JavaScript
• Importing cookies and sessions from Chrome, Firefox, Arc, and 20+ browsers

The browser routes through the remote network during SSH sessions, so localhost URLs on a remote machine just work in a browser split next to that SSH session.

This is particularly useful for agents that need to verify their changes in a browser. Claude Code can interact with your dev server directly through the browser pane.

SSH Workspaces

Running cmux ssh user@remote creates a dedicated workspace for a remote machine. Browser panes route traffic through the remote network. You can drag an image into a remote session to upload it via scp.

For SRE teams managing multiple servers, this means each machine gets its own workspace with full browser routing and notification support.

Claude Code Teams

cmux has first-class support for Claude Code's teammate mode:

cmux claude-teams

Teammates spawn as native terminal splits with sidebar metadata and notifications. No tmux layer required. Each teammate gets its own pane with full notification support, so you can see at a glance which teammate needs guidance.

Scriptable CLI

Everything in cmux is controllable via CLI and socket API:

# Create a new workspace
cmux workspace create --name "backend-refactor"

# Split a pane
cmux split --direction right

# Send keystrokes to a pane
cmux send-keys --text "npm test"

# Open a URL in a browser pane
cmux browser open --url "http://localhost:3000"

# Send a notification
cmux notify --title "Build complete" --body "All tests passed"

This makes cmux composable. You can build custom workflows, project-specific launchers, and automation scripts without being locked into a predefined UX.

Custom Commands

Define project-specific actions in a cmux.json file that launch from the command palette:

{
  "commands": [
    {
      "name": "Start Dev",
      "command": "docker compose up -d && npm run dev"
    },
    {
      "name": "Run Tests",
      "command": "npm test -- --watch"
    },
    {
      "name": "Deploy Staging",
      "command": "./scripts/deploy.sh staging"
    }
  ]
}

Performance

cmux is a native Swift/AppKit app. No Electron. No Tauri. GPU-accelerated rendering via libghostty. This matters when you have 10+ panes open with agents streaming output.

Memory usage and startup time are comparable to Ghostty itself, which is one of the fastest terminals available. We covered Ghostty's performance characteristics in our Ghostty vs Kitty comparison.

Key Shortcuts

Shortcut	Action
Cmd+N	New workspace
Cmd+D	Split right
Cmd+Shift+D	Split down
Cmd+B	Toggle sidebar
Cmd+Shift+U	Jump to most recent unread
Cmd+T	New surface (tab)
Cmd+1-8	Jump to workspace
Option+Cmd+Arrows	Focus pane directionally

Who This Is For

cmux is built for developers who:

• Run multiple AI coding agents in parallel
• Want notification awareness without context-switching
• Prefer terminals over GUI orchestrators
• Need browser testing alongside terminal workflows
• Work across multiple remote machines via SSH

The Philosophy

From the cmux README:

cmux is a primitive, not a solution. It gives you a terminal, a browser, notifications, workspaces, splits, tabs, and a CLI to control all of it.

This aligns with how productive developers actually work. Nobody has figured out the optimal AI agent workflow yet. Rather than shipping an opinionated orchestrator that locks you in, cmux gives you composable building blocks and lets you figure out what works for your codebase.

Limitations

• macOS only. No Linux or Windows support currently.
• Ghostty config dependency. You need to be comfortable with Ghostty's configuration model.
• New project. The API surface is still evolving.

Getting Started

# Install
brew tap manaflow-ai/cmux
brew install --cask cmux

# Launch
open -a cmux

# Or from terminal
cmux

cmux reads your existing Ghostty config, so if you already have themes and fonts configured, they carry over automatically.

Check the official docs for detailed configuration and the demo video for a visual walkthrough.

---

At Akmatori, our AI agents investigate incidents by running diagnostics across multiple systems simultaneously. Tools like cmux that provide notification awareness and scriptable terminal control make multi-agent workflows significantly more manageable.