cmux: The Ultimate macOS Terminal for AI Coding Agents with Vertical Tabs and Smart Notifications (2026)

The terminal landscape for AI-assisted development has been stuck in a paradox: coding agents like Claude Code, Cursor, Codex, and OpenCode have become incredibly powerful, but the terminals running them haven't adapted to the unique challenges of multi-agent workflows. When you're running 5-10 concurrent Claude Code sessions across multiple projects, how do you know which one needs your attention? How do you track which workspace is working on which PR? How do you give agents browser access without juggling separate windows?

Enter cmux, a native macOS terminal built from the ground up for the AI coding era. Created by the team at Manaflow AI, cmux combines Ghostty's blazing-fast GPU-accelerated rendering with a sidebar showing git branches, PR status, listening ports, and intelligent notification rings that light up when agents need you—all wrapped in a native Swift/AppKit interface that feels at home on macOS.

What is cmux?

cmux is a Ghostty-based terminal multiplexer specifically designed for developers working with AI coding agents. It's not another Electron app trying to be a terminal—it's a native macOS application written in Swift and AppKit that uses libghostty for terminal rendering, resulting in fast startup, low memory usage, and smooth performance.

Core Features at a Glance

• Notification Rings: Panes get a blue ring and sidebar tabs light up when agents need attention
• Vertical + Horizontal Tabs: Sidebar shows git branch, PR status/number, working directory, listening ports, and latest notification
• Built-In Browser: Split a scriptable browser alongside your terminal with agent-browser API
• Claude Code Teams: Run cmux claude-teams for native teammate splits with metadata and notifications
• SSH Support: cmux ssh user@remote creates workspaces for remote machines with browser panes that route through remote network
• Session Restore: Auto-save and restore workspace layouts, directories, scrollback, and agent sessions
• Scriptable: Full CLI and socket API to automate workspaces, splits, keystrokes, and browser
• Ghostty Compatible: Reads your existing ~/.config/ghostty/config for themes, fonts, colors
• GPU Accelerated: Powered by libghostty for smooth rendering at 120fps

As of May 2026, cmux has gained significant traction with 18,800+ GitHub stars, nightly builds, and a thriving Discord community.

The Problem cmux Solves

The creator's problem statement (from the README) perfectly captures the pain point:

"I run a lot of Claude Code and Codex sessions in parallel. I was using Ghostty with a bunch of split panes, and relying on native macOS notifications to know when an agent needed me. But Claude Code's notification body is always just 'Claude is waiting for your input' with no context, and with enough tabs open I couldn't even read the titles anymore."

Traditional terminal setups fail in multi-agent workflows:

1. Notification Blindness: macOS notifications from Claude Code all say "Claude is waiting for your input"—no context about which project or what the agent found
2. Tab Overload: With 10+ tabs, you can't see full titles or git branches
3. Context Switching: Jumping between terminal, browser, and filesystem explorer wastes time
4. Lack of Metadata: No quick way to see which workspace is on which PR, which ports are listening, or which agent last spoke
5. Performance: Electron-based orchestrators are sluggish and resource-heavy

cmux addresses all of these with native macOS performance and agent-aware UX.

Key Features Deep Dive

1. Notification Rings and Sidebar Badges

The standout feature: visual notification rings that appear around terminal panes when agents send notifications.

How it works:

• Agents send terminal sequences (OSC 9/99/777) or use cmux notify CLI
• The pane gets a blue ring border
• The sidebar tab lights up with a badge
• Latest notification text appears in the sidebar
• Cmd+Shift+U jumps to the most recent unread
• Cmd+I shows all notifications in a panel

Supported agents:

• Claude Code (via native hooks)
• Codex
• Grok
• OpenCode
• Pi
• Amp
• Cursor CLI
• Gemini
• Rovo Dev
• Copilot
• CodeBuddy
• Factory
• Qoder

Example: Setting up Claude Code notifications

# Install cmux hooks for Claude Code
cmux hooks setup

# Or manually for specific agent
cmux hooks setup codex
cmux hooks setup --agent opencode

Once installed, when Claude Code pauses for approval, the pane gets a visual ring and the sidebar lights up—no more hunting through tabs to find which agent needs you.

2. Vertical Tabs with Rich Metadata

The sidebar is cmux's command center. Each workspace tab displays:

• Git branch (e.g., feature/auth-refactor)
• PR status and number (e.g., #1234 ✓ for merged PR)
• Working directory (viewport-aware path truncation, added in v0.64.10)
• Listening ports (e.g., localhost:3000, localhost:8080)
• Latest notification text (e.g., "Tests failed—review output?")

Keyboard shortcuts:

• Cmd+B: Toggle sidebar
• Opt+Cmd+B: Toggle right sidebar
• Cmd+1–8: Jump to workspace 1–8
• Ctrl+Cmd+] / [: Next/previous workspace

This means at a glance you can see:

• Which workspace is working on which PR
• Which dev server is running where
• Which agent most recently spoke and what they said
• Branch names without git branch commands

3. Built-In Scriptable Browser

cmux includes a full browser pane with a scriptable API ported from agent-browser.

What you can do:

• Split browser next to terminal: Cmd+Shift+L
• Agents can snapshot accessibility tree
• Get element refs, click, fill forms, evaluate JS
• Browser panes run in the same network context (localhost works)
• Import cookies/history from Chrome, Firefox, Arc, and 20+ browsers

Example: Scripting the browser via CLI

# Open URL in browser pane
cmux browser open https://localhost:3000

# Get accessibility tree snapshot
cmux browser snapshot --format json > page-tree.json

# Click an element by ref
cmux browser click --element-id "submit-button"

# Fill a form field
cmux browser fill --element-id "email-input" --value "[email protected]"

# Evaluate JavaScript
cmux browser eval "document.querySelector('.total').innerText"

Use cases:

• Claude Code can inspect your dev server UI and suggest fixes
• Run automated browser tests alongside agent workflows
• Verify API responses in the browser without leaving the terminal
• Give agents direct access to local web UIs for debugging

4. SSH Support with Remote Network Routing

cmux ssh user@remote creates a workspace for a remote machine with special features:

• Browser panes route through the remote network
  • localhost:3000 in browser accesses the remote's localhost:3000
  • No manual SSH tunneling required
• Drag images into terminal to upload via scp
• Workspace sidebar shows remote hostname
• Full terminal state preserved (scrollback, splits)

Example workflow:

# Create remote workspace
cmux ssh deploy@prod-server-01

# Inside the workspace:
cd /var/www/app
npm run dev

# Open Cmd+Shift+L browser, navigate to localhost:3000
# Browser accesses the remote's localhost:3000 automatically

This is a game-changer for remote development—no more juggling SSH tunnels or browser proxy configs.

5. Claude Code Teams Integration

cmux claude-teams runs Claude Code's teammate mode with native cmux integration:

• Each teammate spawns as a native split pane
• Sidebar shows metadata for each teammate (branch, notifications, ports)
• Notification rings work for all teammates
• No tmux required—cmux handles the multiplexing

Before cmux:

# Manual tmux setup for teammates
claude teams start
# ... switch between tmux panes manually, lose sidebar metadata

With cmux:

cmux claude-teams
# Teammates auto-split with full sidebar integration

Each teammate gets its own notification ring, sidebar entry, and terminal surface—managed natively by cmux.

6. Session Restore

Quitting cmux auto-saves the session. On relaunch:

• Window/workspace/pane layout restored
• Working directories preserved
• Terminal scrollback restored (best effort)
• Browser URL and history restored
• Agent sessions resumed (with hooks installed)

What gets restored:

Automatic agent resume:

With hooks installed (cmux hooks setup), agent sessions resume automatically:

# Install hooks (one-time setup)
cmux hooks setup

# Now when you quit cmux and relaunch:
# - Claude Code sessions resume with native `claude resume`
# - Codex sessions resume with `codex resume`
# - Layout, directories, scrollback all restored

Disable auto-resume (keep layout but don't run agent resume commands):

// ~/.config/cmux/cmux.json
{
  "terminal": {
    "autoResumeAgentSessions": false
  }
}

Custom resume commands (for advanced users):

# Attach a custom resume command to current surface
cmux surface resume set --kind tmux --checkpoint work --shell "tmux attach -t work"

# Show current resume bindings
cmux surface resume show --json

# Clear resume binding
cmux surface resume clear --checkpoint work

Manual restore (reapply last session):

# Via menu: File > Reopen Previous Session
# Or keyboard: Cmd+Shift+O
# Or CLI:
cmux restore-session

Session snapshots are stored in ~/Library/Application Support/cmux/ and agent session mappings in ~/.cmuxterm/.

7. Custom Commands and Automation

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

// ~/code/my-app/cmux.json
{
  "commands": [
    {
      "name": "Start dev server",
      "command": "npm run dev"
    },
    {
      "name": "Run tests",
      "command": "npm test -- --watch"
    },
    {
      "name": "Deploy staging",
      "command": "./scripts/deploy-staging.sh"
    }
  ]
}

Access via:

• Cmd+K (command palette)
• Cmd+Shift+P (alternative palette binding)
• CLI: cmux command run "Start dev server"

8. Browser Import (Cookies, History, Sessions)

Import cookies, history, and sessions from 20+ browsers:

• Chrome, Firefox, Arc, Safari
• Edge, Brave, Opera, Vivaldi
• Chromium-based browsers
• More (see full list in docs)

Why this matters:

• Browser panes start authenticated to your dev tools
• No need to log in again to localhost:3000 admin panels
• Copy sessions from your daily browser

How to import:

# Import from Chrome
cmux browser import --source chrome

# Import from Arc
cmux browser import --source arc

# Import from specific Firefox profile
cmux browser import --source firefox --profile "Profile Name"

9. Full Scripting API

cmux is fully scriptable via CLI and socket API.

CLI examples:

# Create workspace
cmux workspace new --name "API Refactor"

# Split panes
cmux split right
cmux split down

# Send keystrokes
cmux send-keys "cd ~/code/api" Enter
cmux send-keys "git checkout -b feature/auth-v2" Enter

# Open browser in split
cmux browser open https://localhost:8080

# Notify
cmux notify "Build complete" --severity info

# Focus pane
cmux focus-pane --direction right

# Close pane
cmux close-pane

Socket API (advanced):

cmux exposes a Unix socket at ~/.cmuxterm/socket for programmatic control:

import socket
import json

sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.connect("/Users/yourname/.cmuxterm/socket")

# Send command
command = {
    "action": "workspace.create",
    "name": "Test Workspace"
}
sock.sendall(json.dumps(command).encode() + b'\n')

response = sock.recv(4096)
print(json.loads(response))

Keyboard Shortcuts Reference

Workspaces

Surfaces (Tabs)

Split Panes

Browser

Notifications

Find

Installation

DMG (Recommended)

Download cmux for macOS

• Open the .dmg and drag cmux to Applications
• Auto-updates via Sparkle (download once, updates automatically)
• On first launch, macOS may ask to confirm—click Open

Homebrew

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

# Update later:
brew upgrade --cask cmux

Nightly Builds

Download cmux NIGHTLY

• Separate app with its own bundle ID (runs alongside stable)
• Built automatically from latest main commit
• Auto-updates via separate Sparkle feed
• Report bugs in #nightly-bugs on Discord

Configuration

cmux reads your existing Ghostty config at ~/.config/ghostty/config:

# ~/.config/ghostty/config
theme = Catppuccin Mocha
font-family = JetBrains Mono
font-size = 14
cursor-style = bar
window-padding-x = 10
window-padding-y = 10

# Keybindings
keybind = ctrl+shift+c=copy_to_clipboard
keybind = ctrl+shift+v=paste_from_clipboard

cmux-specific config goes in ~/.config/cmux/cmux.json:

{
  "terminal": {
    "autoResumeAgentSessions": true
  },
  "sidebar": {
    "showGitBranch": true,
    "showPRStatus": true,
    "showListeningPorts": true,
    "showNotificationPreview": true
  },
  "notifications": {
    "enableRings": true,
    "soundOnNotification": false
  },
  "browser": {
    "defaultSearchEngine": "google",
    "enableDevTools": true
  }
}

Performance Benchmarks

Startup Time (MacBook Pro M1, 16GB RAM):

• cmux: 0.3s (cold start)
• iTerm2: 1.2s
• Warp: 2.1s
• Electron-based terminals: 3-5s

Memory Usage (10 workspaces, 30 panes):

• cmux: ~180MB RSS
• iTerm2: ~350MB
• Warp: ~800MB
• Typical Electron terminal: 1-2GB

Rendering Performance:

• GPU-accelerated via libghostty
• 120fps scrollback (on ProMotion displays)
• Sub-16ms input latency

cmux's native Swift/AppKit architecture and libghostty rendering deliver desktop-class performance without Electron overhead.

Real-World Workflows

Workflow 1: Multi-Project Claude Code Orchestration

Scenario: Working on 3 projects simultaneously with Claude Code on each.

# Workspace 1: Frontend
cmux workspace new --name "Frontend - PR #1234"
cmux ssh deploy@frontend-dev
claude code

# Workspace 2: Backend API
cmux workspace new --name "Backend - PR #1235"
cd ~/code/api
cmux split right
cmux browser open http://localhost:8080/docs  # Left: terminal, Right: API docs
claude code

# Workspace 3: Infrastructure
cmux workspace new --name "Infrastructure - k8s migration"
cd ~/code/infrastructure
claude code

# Now:
# - Cmd+1, Cmd+2, Cmd+3 to jump between workspaces
# - Sidebar shows git branch and PR number for each
# - Blue rings appear when any Claude needs attention
# - Cmd+Shift+U jumps to most recent unread agent

Workflow 2: Full-Stack Development with Browser Integration

# Main workspace
cmux workspace new --name "E-commerce App"

# Top-left: Backend
cd ~/code/ecommerce/backend
npm run dev  # Starts on localhost:3001

# Top-right: Frontend
cmux split right
cd ~/code/ecommerce/frontend
npm run dev  # Starts on localhost:3000

# Bottom: Browser
cmux split down
cmux browser open http://localhost:3000

# Sidebar shows:
# - Branch: feature/checkout-v2
# - Ports: 3000, 3001
# - Latest notification from Claude (if running)

# Now Claude Code can:
# - Inspect the browser DOM
# - Click buttons and fill forms
# - Screenshot and analyze UI bugs
# - Suggest fixes based on live browser state

Workflow 3: Remote Development with SSH

# Connect to remote dev server
cmux ssh [email protected]

# Inside remote workspace:
cd /opt/app
docker-compose up  # Starts services on remote's localhost

# Open browser (routes through remote)
cmux split right
cmux browser open http://localhost:8080

# Browser accesses remote's localhost:8080
# No SSH tunneling required!

# Sidebar shows:
# - Workspace: [email protected]
# - Working dir: /opt/app
# - Ports: 8080 (remote), 5432 (remote DB)

Workflow 4: Claude Code Teams

cd ~/code/large-refactor
cmux claude-teams

# cmux automatically:
# - Spawns teammate splits
# - Shows sidebar metadata for each teammate
# - Enables notification rings for all
# - Coordinates on shared task

# Teammates work in parallel:
# - Teammate 1: Refactor auth module
# - Teammate 2: Update tests
# - Teammate 3: Update docs

# Sidebar shows which teammate needs you
# Cmd+Shift+U jumps to unread teammate notifications

Comparing cmux to Alternatives

When to use cmux vs. alternatives:

• Use cmux if you work with AI coding agents (Claude Code, Codex, etc.) and want native macOS performance with agent-aware features
• Use Ghostty if you want a minimal, ultra-fast terminal without agent integration
• Use iTerm2 if you need mature Python scripting and don't care about modern UI
• Use Warp if you want AI autocomplete in the terminal itself (vs. external agents)
• Use tmux + terminal if you need maximum portability and remote resilience

The Zen of cmux

From the README's philosophy section:

"cmux is not prescriptive about how developers hold their tools. It's a terminal and browser with a CLI, and the rest is up to you."

"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. cmux doesn't force you into an opinionated way to use coding agents. What you build with the primitives is yours."

"The best developers have always built their own tools. Nobody has figured out the best way to work with agents yet, and the teams building closed products definitely haven't either. The developers closest to their own codebases will figure it out first."

This philosophy is refreshing in a landscape dominated by opinionated orchestrators that lock you into specific workflows. cmux gives you composable primitives—workspaces, splits, notifications, browser, scripting—and lets you build your own agent workflows.

Founder's Edition

cmux is free and open source under GPL-3.0. For users who want to support development and get early access:

Get Founder's Edition

Perks:

• Prioritized feature requests/bug fixes
• Early access: cmux AI (context on every workspace/tab/panel)
• Early access: iOS app (terminals synced between desktop and phone)
• Early access: Cloud VMs
• Early access: Voice mode
• Direct line to founders (personal iMessage/WhatsApp)

The pricing supports sustainable open-source development while keeping the core product free.

Community and Support

• Discord: Join the conversation
• GitHub Issues: Report bugs and request features
• X / Twitter: @manaflowai, @lawrencecchen, @austinywang
• YouTube: Video tutorials and demos
• LinkedIn: Manaflow AI
• Reddit: r/cmux

Roadmap and Future Features

Based on Founder's Edition previews and GitHub discussions:

Confirmed Upcoming Features

1. cmux AI (Early access for Founder's Edition)

• Context-aware AI that understands every workspace, tab, and panel
• Suggests next actions based on git state, notifications, and listening ports
• Proactive debugging assistance

2. iOS App (Early access for Founder's Edition)

• Terminals synced between macOS and iPhone
• View agent notifications on mobile
• Trigger workspace commands from phone

3. Cloud VMs (Early access for Founder's Edition)

• Spin up cloud dev environments directly from cmux
• SSH workspaces auto-configure for cloud VMs
• Pay-as-you-go GPU instances for AI agent tasks

4. Voice Mode (Early access for Founder's Edition)

• Voice commands for workspace navigation
• Dictate terminal commands
• Voice notifications when agents need attention

Community-Requested Features

• Windows/Linux support (currently macOS-only)
• Theme marketplace (community-contributed Ghostty themes)
• Extension API (third-party plugins for notifications, metadata)
• Team collaboration (shared workspaces, presence indicators)
• Recording/playback (record agent sessions for review)

Getting Started Guide

Step 1: Install cmux

# Via Homebrew
brew tap manaflow-ai/cmux
brew install --cask cmux

# Or download DMG from https://cmux.com

Step 2: Install agent hooks (optional but recommended)

# Install hooks for all detected agents
cmux hooks setup

# Or specific agents
cmux hooks setup codex
cmux hooks setup --agent opencode

Step 3: Create your first workspace

# Launch cmux
# Cmd+N to create new workspace
# Or via CLI:
cmux workspace new --name "My Project"

Step 4: Try split browser

# Inside a workspace:
# Cmd+Shift+L to open browser in split
# Navigate to localhost:3000 or any dev server

Step 5: Run a Claude Code session

cd ~/code/your-project
claude code

# When Claude pauses for approval:
# - Pane gets blue notification ring
# - Sidebar tab lights up
# - Latest notification text appears in sidebar

Step 6: Explore keyboard shortcuts

• Cmd+K: Command palette
• Cmd+1–8: Jump to workspaces
• Cmd+Shift+U: Jump to latest unread notification
• Cmd+B: Toggle sidebar
• Cmd+D: Split right
• Cmd+Shift+D: Split down

Troubleshooting

Issue: Notification rings not appearing

Solution:

• Verify hooks are installed: cmux hooks setup
• Check agent is supported (Claude Code, Codex, OpenCode, etc.)
• Enable notification rings in Settings → Notifications

Issue: Session restore not working

Solution:

• Verify hooks installed for your agent: cmux hooks setup
• Check auto-resume setting: Settings → Terminal → Resume Agent Sessions on Reopen
• View session snapshot: ~/Library/Application Support/cmux/

Issue: Browser localhost not working in SSH workspace

Solution:

• Verify workspace was created with cmux ssh user@host (not manual ssh)
• Check remote ports are listening: ss -tuln | grep LISTEN
• Ensure SSH connection is active

Issue: High memory usage

Solution:

• Check number of workspaces and scrollback: Settings → Terminal → Scrollback Lines
• Reduce scrollback limit (default: 10,000 lines)
• Close unused workspaces

Issue: Keybindings conflict with Ghostty config

Solution:

• cmux keybindings take precedence over Ghostty
• Customize in Settings → Keyboard Shortcuts
• Or edit ~/.config/cmux/keybindings.json

Conclusion

cmux represents a fundamental shift in how we think about terminals for AI-assisted development. By treating agent notifications as first-class citizens, integrating a scriptable browser, and surfacing rich workspace metadata in the sidebar, it solves the core pain points of multi-agent workflows that generic terminals ignore.

Its native macOS architecture delivers desktop-class performance without Electron bloat, while Ghostty compatibility means you keep your existing config and themes. The full scripting API makes it a platform for building custom agent orchestration workflows—not a locked-down product.

Whether you're running a single Claude Code session or coordinating 10 teammates across multiple projects, cmux gives you the visibility and control to stay productive without tab overload or notification blindness.

Key Takeaways:

• ✅ Visual notification rings solve "which agent needs me?" across multiple sessions
• ✅ Vertical tabs with metadata (git branch, PR, ports) provide instant context
• ✅ Built-in browser lets agents interact with local UIs without window juggling
• ✅ SSH with remote browser routing makes remote dev feel local
• ✅ Native macOS performance (0.3s startup, 180MB memory) beats Electron alternatives
• ✅ Session restore preserves layouts, directories, scrollback, and agent sessions
• ✅ Fully scriptable via CLI and socket API for custom workflows
• ✅ Free and open source (GPL-3.0) with optional Founder's Edition

If you're working with AI coding agents in 2026, cmux is the terminal you didn't know you needed.

Get started today:

Download cmux for macOS

Join 18,800+ developers building the future of AI-assisted coding—one workspace at a time.