Ep 3: cmux — The Terminal Built for AI Agents

Released in 2026, cmux is based on the Ghostty engine and introduces vertical tabs, notification rings, and a robust Socket API to address the challenges of managing multiple AI Agents.

Core Philosophy

The bottleneck in running multiple Agents in parallel isn't computing power—it's human attention.

When running 5 Agents simultaneously, you need to know:

• Who needs input? (Agent is stuck waiting for your response)
• Who finished? (You can check the results)
• Who errored out? (Requires manual intervention)

Without a notification mechanism, you're forced to manually flip through tabs to check status—an efficiency disaster.

cmux's solution: Notification Rings. When an Agent needs your attention, its tab automatically flashes, accompanied by a system notification.

Installation

macOS (The only natively supported platform):

# Option 1: Homebrew (Recommended)
brew install --cask cmux

# Option 2: DMG download from official site
# https://cmux.com/

# Option 3: Manual download from GitHub
# https://github.com/nickelc/cmux/releases

Operating System Support

Note: Linux and Windows versions are community projects and may lack the stability and features of the native macOS version.

Core Features

1. Vertical Tab Bar

A column of tabs on the left, each representing an Agent session. See all Agent statuses at a glance.

┌──────┬─────────────────────────────────┐
│ ▶ P1 │                                 │
│   P2 │   Claude Code Session           │
│ ● P3 │   > /gsd-execute-phase 1        │
│   P4 │                                 │
│   P5 │   [Running task 3/12...]        │
│      │                                 │
└──────┴─────────────────────────────────┘

• ▶ = Needs input
• ● = Notification (Completed/Error)
• Blank = Running normally

2. Notification Rings

When an Agent needs input, finishes a task, or errors out:

• A colored ring flashes on the corresponding tab.
• A macOS system notification pops up.
• Clicking the notification jumps directly to that Agent session.

3. Built-in Browser

Open a browser panel on the right to check documentation, read APIs, or review GitHub PRs—without leaving your terminal.

┌──────┬────────────────────┬────────────────────┐
│ Tab  │  Claude Code       │  Built-in Browser    │
│ Bar  │  Agent Session     │  docs.anthropic.com │
│      │                    │                    │
└──────┴────────────────────┴────────────────────┘

4. Split Panels

Supports horizontal and vertical splitting to compare code or monitor two Agents side-by-side.

5. Socket API

Provides a full Socket API for batch management of Agents via scripts. See "Agent Interaction Mechanism" below.

Agent Interaction Mechanism

cmux offers some of the most powerful Agent interaction capabilities among all terminals:

flowchart TB
    subgraph Script Automation
        A[Startup Script] -->|Socket API| B[cmux Process]
        B -->|Create Tab| C[Agent 1]
        B -->|Create Tab| D[Agent 2]
        B -->|Create Tab| E[Agent N...]
    end

    subgraph Notification Mechanism
        C -->|Needs Input| F[Ring Flashing]
        D -->|Task Complete| G[Desktop Alert]
        E -->|Error| F
        F --> H[Click to Jump]
        G --> H
    end

    subgraph Human Intervention
        H --> I[Input Response]
        I --> C
    end

    style B fill:#4a9eff,color:#fff
    style F fill:#ff6b6b,color:#fff

Socket API Example:

# Python example: Batch starting 5 Claude Code Agents
import socket
import json

def send_cmux_command(command):
    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    sock.connect('/tmp/cmux.sock')
    sock.send(json.dumps(command).encode())
    response = sock.recv(4096)
    sock.close()
    return json.loads(response)

# Create 5 tabs, each starting a Claude Code instance
for i in range(1, 6):
    send_cmux_command({
        "action": "new_tab",
        "name": f"agent-{i}",
        "command": "claude"
    })

10 Agent Parallel Management Workflow

sequenceDiagram
    participant User as Developer
    participant Script as Startup Script
    participant Cmux as cmux
    participant A1 as Agent 1
(Phase 1)
    participant A2 as Agent 2
(Phase 2)
    participant A3 as Agent 3
(Tests)

    User->>Script: Run startup script
    Script->>Cmux: Socket API: Create 3 tabs
    Cmux->>A1: Start claude
    Cmux->>A2: Start claude
    Cmux->>A3: Start claude

    Note over Cmux: Three tabs run in parallel
Notification rings monitor status

    A1->>Cmux: ⏸ Needs user input
    Cmux->>User: 🔔 Ring flashes + Desktop alert
    User->>A1: Input decision
    A1->>Cmux: ✅ Continue running

    A2->>Cmux: ✅ Phase 2 complete
    Cmux->>User: 🔔 Completion notification

    A3->>Cmux: ❌ Test failed
    Cmux->>User: 🔔 Error notification
    User->>A3: Intervene to debug

Pros & Cons

Best Use Cases

• Running 3-10 Agents in parallel locally on macOS
• Scenarios requiring Agent status notifications and attention management
• Standardized terminal solution for macOS-based teams