cmux: The Open-Source Terminal Built for AI Agent Multitasking

Yxy
Opensource , Terminal , AI Agent
17 Jul, 2026

The Problem

You know the scenario: five terminal windows open, each running a different AI agent. One is waiting for your confirmation, another is running tests, the third is stuck compiling, the fourth is waiting for an API response, and you forgot what the fifth one was for.

Switching windows? You have no idea which one needs you. By the time you find it, the agent might have already timed out.

This is the typical pain point of multi-agent workflows. iTerm2 and Terminal.app are solid terminals, but they weren’t designed for “monitoring multiple long-running agents simultaneously.” You’re forced to manually switch between windows, relying on visual inspection to spot which one is producing new output.

cmux solves this: it turns “multiple terminal windows” into “multiple panes in one interface” and tells you which one needs attention.

What It Is

cmux is an open-source macOS terminal built on Ghostty’s rendering engine libghostty, developed by the Manaflow team. It uses libghostty the same way apps use WebKit to render web pages. The entire app is written in native Swift + AppKit — no Electron, no web stack.

The GitHub repository is manaflow-ai/cmux, licensed under GPL, free to use.

The positioning is clear: a terminal designed for multitasking and AI coding agent workflows. It’s not trying to replace iTerm2 for everything — it solves the specific problem of organizing and monitoring multiple concurrent agents.

Core features from the README:

Vertical tabs: Sidebar shows git branch, working directory, port info, and notification status
Notification rings: Panel lights up when an agent needs attention
Built-in browser: Split-pane browser with programmable API
Split panes: Horizontal and vertical splits within each workspace
Programmable: CLI and socket API for automation and scripting
GPU-accelerated: Powered by libghostty for smooth rendering
Session restore: Recovers windows, workspaces, panes, working directory, and scrollback after restart
iOS companion app: Mirror your terminal to iPhone and iPad in real-time

Why It Stands Out

Notification System: The Core of Multi-Agent Workflows

What does “notification” mean in most terminals? A title bar flash. If you’re not staring at it, you’ll miss it entirely.

cmux’s notifications are multi-dimensional:

Notification rings (glowing borders) around the panel
Unread markers in the sidebar
Notification panel popup
macOS desktop notifications

These trigger automatically via standard terminal escape sequences (OSC 9/99/777). Any agent that supports hooks or OSC works, including Claude Code, Codex, and OpenCode.

Translation: when Claude Code finishes a task and waits for your confirmation, cmux tells you directly. No more hunting through five windows to find which agent is waiting.

Vertical Tabs: More Practical Than Horizontal

Horizontal tabs lose readability past five items.

cmux’s vertical tabs in the sidebar show:

Workspace name
Current git branch
Working directory
Port information
Notification status

You see all ongoing tasks at a glance. Much higher information density than horizontal tabs.

Built-in Browser: Verify Changes Without Switching Windows

cmux can open a real browser panel alongside the terminal, fully programmable. You can:

Navigate to URLs
Screenshot the DOM
Click, type, interact
Execute JavaScript
Read console and network activity

Useful for agent workflows: when an agent modifies code, you verify in the adjacent browser without context-switching.

Programmability: Not Just a Terminal, an Automation Platform

cmux provides a CLI and Unix socket API. Every operation can be controlled from the command line:

# Create a workspace
cmux create-workspace --name "project-a"

# Open a split pane
cmux split-pane --horizontal

# Send input to a specific pane
cmux send-input --workspace "project-a" --pane 0 --input "npm test"

# Capture screen content
cmux capture-pane --workspace "project-a" --pane 0

This means you can write scripts to batch-manage agent workflows instead of operating manually.

How It Compares to tmux

tmux is a terminal multiplexer that runs inside any terminal. cmux is a native macOS app with a GUI. Vertical tabs, split panes, a built-in browser, and socket API are all built in — no config files or prefix keys required.

But cmux doesn’t reject tmux. Many people use cmux with SSH and tmux, and cmux can natively connect to remote tmux sessions.

How It Compares to iTerm2

Feature	cmux	iTerm2
Native macOS	Yes	Yes
Vertical tabs	Native	Requires config
Notification rings	Native	No
Built-in browser	Native	No
Programmable API	CLI + socket	AppleScript
GPU acceleration	Yes	No
Session restore	Yes	Partial
Open source	Yes	No

iTerm2 is a mature, feature-rich terminal. But cmux focuses on the “multi-agent workflow” use case with a more targeted experience.

Quick Start

Installation

DMG install is recommended:

# Download from the official site
# https://cmux.com/zh-CN/download/confirmation?dl=1

# Or use Homebrew
brew tap manaflow-ai/cmux
brew install --cask cmux

On first launch, macOS may ask for confirmation to open an app from an identified developer. Click “Open” to continue.

CLI Setup

cmux includes a CLI tool for automation. It works automatically inside cmux terminals. To use the CLI outside cmux, create a symlink:

sudo ln -sf "/Applications/cmux.app/Contents/Resources/bin/cmux" /usr/local/bin/cmux

Then you can run:

# List all workspaces
cmux list-workspaces

# Send a notification
cmux notify --title "Build Complete" --body "Your build finished"

Basic Operations

Open cmux — you’ll see a vertical tab sidebar on the left
A default workspace with one terminal is already open
Use keyboard shortcuts to create new workspaces and splits

Key shortcuts:

Cmd + N: New workspace
Cmd + D: Vertical split
Cmd + Shift + D: Horizontal split
Cmd + [: Switch to left pane
Cmd + ]: Switch to right pane

Full shortcut list: https://cmux.com/docs/keyboard-shortcuts

Highlight Code

cmux’s most valuable features are the notification system and programmable API. Here’s a practical scenario: managing multiple Claude Code sessions with cmux.

Scenario: Running 3 Agents in Parallel

Suppose you’re handling three tasks concurrently:

Frontend refactor (Claude Code session A)
API development (Claude Code session B)
Test writing (Claude Code session C)

In cmux:

Create 3 workspaces, each named appropriately
Launch Claude Code in each workspace
When an agent finishes and waits for confirmation, cmux alerts you with notification rings
The sidebar shows at a glance which agent is running and which is waiting

Batch Management with Scripts

#!/bin/bash
# batch-agents.sh: Create and launch multiple agent workspaces

# Create workspaces
cmux create-workspace --name "frontend"
cmux create-workspace --name "api"
cmux create-workspace --name "tests"

# Launch Claude Code in each workspace
cmux send-input --workspace "frontend" --input "claude"
cmux send-input --workspace "api" --input "claude"
cmux send-input --workspace "tests" --input "claude"

# Send initial tasks
cmux send-input --workspace "frontend" --input "Refactor login page components"
cmux send-input --workspace "api" --input "Implement user authentication API"
cmux send-input --workspace "tests" --input "Write authentication module tests"

After running this script, cmux monitors all agents and notifies you when confirmation is needed.

Browser Automation Example

# Open browser panel and navigate
cmux browser navigate --url "http://localhost:3000"

# Screenshot to verify the page
cmux browser screenshot --output "login-page.png"

# Evaluate JavaScript to check elements
cmux browser evaluate --expression "document.querySelector('button').textContent"

Community and Ecosystem

cmux is developed by the Manaflow team, with an active GitHub repository. Community feedback shows it has already gained a loyal user base.

Mitchell Hashimoto (Ghostty creator, HashiCorp founder) commented:

“Another libghostty-based project — this time a macOS terminal with vertical tabs, better organization/notifications, embedded/scriptable browser specifically targeted towards people who use a ton of terminal-based agentic workflows.”

Nick Schrock (Creator of Dagster, GraphQL co-creator) said:

“This is exactly the product I’ve been looking for. After two hours this morning I’m in love.”

Edward Grefenstette (Director of Research at Google DeepMind) said:

“I’ve been using this all weekend and it’s amazing.”

Based on this feedback, cmux’s core users are developers who need to manage multiple agents concurrently. It’s not a general-purpose terminal replacement — it’s a tool designed for a specific workflow.

The project is under active development, with Linux, Windows, and Android support coming soon. An iOS companion app is already available in beta.

When to Use It (and When Not To)

Good fit

Running multiple AI coding agents concurrently (Claude Code, Codex, OpenCode, etc.)
Need to monitor agent status and respond promptly
Want to organize multiple development tasks in one interface
Need to view the terminal and browser side-by-side to verify changes
Want programmable terminal automation capabilities

Bad fit

Running only one agent — no need for multi-task management
Must work on Linux or Windows (macOS only for now)
Prefer the look and feel of other terminals (cmux is functional, not pretty)
Need highly customized terminal experiences (iTerm2 is more mature)

Current Limitations

macOS only — Linux and Windows versions are coming soon
Session restore is limited: layout and metadata survive restart, but active terminal processes (Claude Code, tmux, vim) don’t auto-resume
Browser panel is still maturing
Feature set is smaller than iTerm2 overall

Conclusion

cmux isn’t a general-purpose terminal replacement. It solves a specific problem: organizing and notifying across multiple AI agents.

If you run 3+ agents concurrently and keep losing time because you missed confirmations, cmux is worth trying. Its notification system and vertical tabs will change how you think about “multitasking in the terminal.”

Repository: https://github.com/manaflow-ai/cmux Docs: https://cmux.com/docs/getting-started