Overview

tmux, born in 2007, has been a cornerstone of server management and development environments for 19 years. Claude Code’s Agent Team feature recently put it back in the spotlight by spawning parallel agents on top of tmux sessions. Meanwhile, cmux — built by Manaflow AI — arrived with the concept of “a terminal built for AI agents.” It’s a native macOS app based on Ghostty’s rendering engine (libghostty).

This post compares the two tools’ architectures, core concepts, and AI agent support models, and suggests how to combine them effectively in practice.

Architecture Comparison

The two tools have fundamentally different design philosophies.

graph LR
    subgraph tmux["tmux (Server-Client)"]
        S["tmux server"] --> C1["Client 1"]
        S --> C2["Client 2"]
        S --> C3["Client 3"]
        S --> SE1["Session 1"]
        S --> SE2["Session 2"]
        SE1 --> W1["Window 1"]
        SE1 --> W2["Window 2"]
        W1 --> P1["Pane 1"]
        W1 --> P2["Pane 2"]
    end

    subgraph cmux["cmux (Native macOS App)"]
        APP["cmux.app <br/> Swift + AppKit"] --> WS1["Workspace 1 <br/> git branch, PR, ports"]
        APP --> WS2["Workspace 2"]
        WS1 --> SF1["Surface 1"]
        WS1 --> SF2["Surface 2"]
        SF1 --> PA1["Pane A"]
        SF1 --> PA2["Pane B"]
    end

tmux uses a server process that manages all sessions while clients connect to view them. Sessions persist even if the terminal is closed, as long as the server is alive. cmux is a native macOS app that displays workspace metadata — git branch, PR status, open ports, notifications — visually in a sidebar.

Core Concept Mapping

The two tools’ hierarchies have a clear correspondence.

How Navigation Differs

tmux uses a prefix key approach. Press Ctrl+b first, then enter a command key. The learning curve is steep, but everything can be controlled with just a keyboard.

cmux uses native macOS shortcuts. No prefix required — actions fire immediately.

AI Agent Support

This is where the two tools differ most significantly.

flowchart TB
    subgraph tmux_flow["tmux + AI Agent"]
        A1["Claude Code <br/> Agent Team"] -->|"tmux new-session"| A2["tmux session"]
        A2 -->|"tmux send-keys"| A3["Agent Pane 1"]
        A2 -->|"tmux send-keys"| A4["Agent Pane 2"]
        A2 -->|"tmux send-keys"| A5["Agent Pane 3"]
        A3 -->|"tmux capture-pane"| A6["Collect results"]
        A4 -->|"tmux capture-pane"| A6
        A5 -->|"tmux capture-pane"| A6
    end

    subgraph cmux_flow["cmux + AI Agent"]
        B1["AI Agent"] -->|"cmux new-workspace"| B2["Workspace"]
        B2 -->|"cmux split"| B3["Pane A"]
        B2 -->|"cmux split"| B4["Pane B"]
        B3 -->|"cmux send"| B5["Run command"]
        B4 -->|"cmux read-screen"| B6["Read another pane <br/> (inter-agent communication)"]
        B2 -->|"notification system"| B7["macOS notification <br/> + blue ring indicator <br/> + unread badge"]
    end

tmux’s AI Agent Usage

tmux wasn’t originally designed for AI. But its programmable API lets AI tools leverage it.

• Claude Code: Creates tmux sessions to run parallel agents in Agent Team mode
• Codex, Gemini CLI: Use tmux in a similar way
• tmux send-keys sends commands; tmux capture-pane collects output

cmux’s Native AI Support

cmux was designed for AI agents from the ground up.

• Notification system: Blue ring on panes waiting for input, unread badges on workspace tabs, macOS desktop notifications. Cmd+Shift+U jumps to the most recent notification.
• read-screen: One pane can read another pane’s content. This is the core feature for inter-agent communication.
• send: Programmatically send commands to another pane.
• Environment variables: CMUX_WORKSPACE_ID, CMUX_SURFACE_ID, CMUX_SOCKET_PATH — agents automatically know their own context.
• Built-in browser: Open web pages inside the terminal.

CLI Automation Comparison

# tmux — programmatic control
tmux new-session -d -s work
tmux split-window -h
tmux send-keys -t work:0.1 "npm run dev" Enter
tmux capture-pane -t work:0.0 -p

# cmux — AI agent-dedicated CLI
cmux new-workspace
cmux split --direction right
cmux send --pane-id $CMUX_PANE_ID "npm run dev"
cmux read-screen --pane-id $TARGET_PANE_ID

“Primitive, Not Solution” Philosophy

cmux’s core design philosophy is “Primitive, Not Solution.” Rather than providing a finished workflow, it offers low-level building blocks — read-screen, send, notifications. It leaves AI agents to combine these elements and compose their own workflows.

This approach increases compatibility with diverse AI tools and maximizes agent autonomy.

The Competitive Landscape

The AI agent terminal space is growing quickly.

Recommended Combination: tmux + cmux

In conclusion, tmux and cmux are not substitutes — they’re complements.

• tmux: Session persistence (server-based), cross-platform support, remote server work
• cmux: GUI visualization, AI agent notifications, inter-agent communication (read-screen)

For local macOS development with AI agents, cmux works well as the primary tool, with tmux alongside for remote server work or when session persistence is required. That combination is currently the most effective terminal setup.

Installation

# tmux
brew install tmux

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

Quick Links

• tmux GitHub — 43,430 stars, C-based open source
• cmux official site — Manaflow AI
• cmux: Terminal for Coding Agents — Dale Seo — practical guide
• tmux vs cmux comparison — goddaehee — from installation to competitive tools
• TMUX Masterclass — YouTube

Takeaways

tmux’s strength is 19 years of proven stability and cross-platform support. It remains the top choice for every scenario involving remote servers, CI/CD, and session persistence. cmux is designed for the AI agent era, with its notification system and read-screen feature optimized for multi-agent workflows. The two are not substitutes — they’re complements. If tmux is “infrastructure where sessions never die,” cmux is “the interface where agents talk to each other.” AI coding tools spawning agents on top of tmux, with cmux visually managing those agents’ state, is currently the most powerful terminal environment you can build.