cmux: The Ultimate macOS Terminal for AI Coding Agents with Vertical Tabs and Smart Notifications (2026)
Discover cmux, a native macOS terminal built on Ghostty designed for AI coding workflows. Features vertical tabs, intelligent notifications, built-in browser, SSH support, and Claude Code Teams integration—all in a GPU-accelerated native Swift app.
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:
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
Tab Overload: With 10+ tabs, you can't see full titles or git branches
Context Switching: Jumping between terminal, browser, and filesystem explorer wastes time
Lack of Metadata: No quick way to see which workspace is on which PR, which ports are listening, or which agent last spoke
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
bash
# 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)
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
bash
# 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:
bash
# 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:
bash
# Manual tmux setup for teammates
claude teams start
# ... switch between tmux panes manually, lose sidebar metadata
With cmux:
bash
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:
State
Restored?
Layout (windows, workspaces, splits)
✅
Working directories
✅
Terminal scrollback
✅ (best effort)
Browser tabs/history
✅
Claude Code sessions
✅ (with hooks)
Codex sessions
✅ (with hooks)
tmux sessions
✅ (with custom resume bindings)
Arbitrary process state (vim, shells)
❌ (reopen as blank terminals)
Automatic agent resume:
With hooks installed (cmux hooks setup), agent sessions resume automatically:
bash
# 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):
# 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):
bash
# 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:
json
// ~/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:
bash
# 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:
bash
# 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:
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.
bash
# 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
bash
# Main workspace
cmux workspace new --name "E-commerce App"# Top-left: Backendcd ~/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
bash
# 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
bash
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
Feature
cmux
iTerm2
Warp
Tabby
Ghostty
tmux + terminal
Native macOS
✅ Swift/AppKit
✅ Objective-C
❌ Rust/Electron
❌ Electron
✅ Zig/macOS
✅ Varies
GPU Acceleration
✅ libghostty
✅ Metal
✅
✅
✅ Metal
❌
Vertical Tabs
✅
❌
✅
✅
❌
❌
Agent Notifications
✅ Visual rings
❌
❌
❌
❌
❌
Git/PR Metadata
✅ Sidebar
❌
Partial
❌
❌
❌
Built-In Browser
✅ Scriptable
❌
❌
❌
❌
❌
SSH with Remote Browser
✅
❌
❌
❌
❌
❌
Session Restore
✅ Agent-aware
Partial
✅
✅
❌
✅ tmux
Scripting API
✅ CLI + socket
✅ Python API
Partial
❌
❌
✅ tmux
Startup Time
0.3s
1.2s
2.1s
3s+
0.2s
Instant
Memory (10 workspaces)
180MB
350MB
800MB
1-2GB
100MB
50MB
AI Agent Focus
✅
❌
✅
❌
❌
❌
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:
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
bash
# 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)
bash
# 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
bash
# Launch cmux# Cmd+N to create new workspace# Or via CLI:
cmux workspace new --name "My Project"
Step 4: Try split browser
bash
# 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
bash
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
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.
