cmux: a purpose-built terminal for the parallel agent workflow

Five Claude Code sessions. Three Ghostty tabs. Two split panes each. Every single macOS notification says the same thing: “Claude is waiting for your input.” You alt-tab through them, trying to remember which session was refactoring the auth middleware and which one was writing tests. By the time you find the right pane, you’ve lost your train of thought on the PR you were reviewing.

This is the problem cmux was built to solve.

Not what you think it is

The name suggests a tmux alternative. It isn’t. cmux is a standalone native macOS terminal application — a full .app you drag into Applications. It’s built with Swift and AppKit (no Electron, no Tauri), and uses libghostty, the rendering engine behind Mitchell Hashimoto’s Ghostty terminal, for GPU-accelerated terminal emulation.

If you already use Ghostty, cmux reads your existing ~/.config/ghostty/config for fonts, themes, and colours. No separate config file to maintain.

The project comes from Manaflow AI, created by Lawrence Chen and Austin Wang. It’s open source under AGPL-3.0, with around 5,000 GitHub stars since its January 2026 launch. Hashimoto himself described it as “another libghostty-based project with vertical tabs, better organization/notifications, embedded/scriptable browser specifically targeted towards people who use a ton of terminal-based agentic workflows.”

Notifications that actually tell you something

The notification system is the feature people keep coming back to. When an agent in any pane needs attention, three things happen:

1. The pane gets a blue ring around its border
2. The workspace tab in the sidebar shows an unread badge with the notification text
3. A macOS desktop notification fires (suppressed when you’re already looking at that workspace)

You can jump to the most recent unread pane with Cmd+Shift+U, or open a notification panel with Cmd+Shift+I to see all pending requests across every workspace.

For Claude Code specifically, cmux ships with first-class hook integration. A cmux claude-hook command plugs into Claude Code’s lifecycle events, so notifications fire automatically on session start, tool use, and task completion — no manual setup per session. The hook state persists to ~/.cmuxterm/claude-hook-sessions.json, mapping each Claude session to its workspace and surface.

You can also wire up custom notification commands in Settings. cmux exposes CMUX_NOTIFICATION_TITLE, CMUX_NOTIFICATION_SUBTITLE, and CMUX_NOTIFICATION_BODY as environment variables, so you can pipe alerts to Slack, ntfy, or whatever you want.

The sidebar changes how you think about tabs

cmux replaces horizontal tabs with a vertical sidebar. Each workspace tab shows contextual metadata that updates automatically:

• Git branch currently checked out
• PR status and number (if linked)
• Working directory path
• Listening ports (so you can see which agent spun up a dev server)
• Latest notification text

You can colour-code workspaces, rename them, and reorder with drag-and-drop. Cmd+1 through Cmd+9 switches between them. It sounds simple, but when you’re running six agents across different repos, glancing at the sidebar and seeing “feature/auth-refactor — PR #42 — :3000” is worth more than any amount of tab-hovering.

A browser next to your terminal

Cmd+Shift+L opens a WebKit-based browser panel split alongside your terminal panes. This alone is useful for keeping docs or a PR diff visible while an agent works. But the interesting part is that the browser is scriptable.

The browser API is ported from Vercel’s agent-browser project. Through the CLI or socket API, agents can:

# Open a browser pane and wait for it to load
cmux new-pane --type browser --url https://github.com/your/repo/pull/42
cmux browser wait --surface surface:3 --load-state complete

# Snapshot the accessibility tree with element references
cmux browser snapshot --surface surface:3 --interactive

# Interact with page elements
cmux browser click --surface surface:3 'e14'
cmux browser type --surface surface:3 'e10' 'search query'

This means an orchestrating agent can open a PR, read the diff, check CI status, and post a comment — all within cmux, without needing a separate browser automation tool.

The socket API makes it programmable

cmux exposes a Unix domain socket at /tmp/cmux.sock that accepts JSON-RPC over newline-delimited messages. The CLI is a thin wrapper around this socket, but you can also hit it directly from any language.

Here’s a Python client that lists workspaces and fires a notification:

import json, os, socket

SOCKET_PATH = os.environ.get("CMUX_SOCKET_PATH", "/tmp/cmux.sock")

def rpc(method, params=None, req_id=1):
    payload = {"id": req_id, "method": method, "params": params or {}}
    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
        sock.connect(SOCKET_PATH)
        sock.sendall(json.dumps(payload).encode("utf-8") + b"\n")
        return json.loads(sock.recv(65536).decode("utf-8"))

print(rpc("workspace.list"))
print(rpc("notification.create", {"title": "Build done", "body": "All tests passing"}))

The practical upshot is agent orchestration. A primary agent can spawn sub-agents in separate panes, send them tasks, and read their output:

# Create two splits for parallel work
cmux new-split right
cmux new-split down

# Launch Claude Code in each
cmux send --surface surface:7 "claude"
cmux send-key --surface surface:7 "Return"
cmux send --surface surface:8 "claude"
cmux send-key --surface surface:8 "Return"

# Assign different tasks
cmux send --surface surface:7 "refactor the auth middleware to use JWT"
cmux send --surface surface:8 "write integration tests for the payments API"

# Later, read back what happened
cmux read-screen --surface surface:7

The CLI covers windows, workspaces, panes, surfaces, input, notifications, status bars, logging, and browser automation — over 40 subcommands in total. Inside cmux terminals, CMUX_WORKSPACE_ID and CMUX_SURFACE_ID are set automatically so commands know which pane they’re running in.

A crowded space

cmux isn’t the only tool trying to solve this. The past six months have produced a remarkable proliferation of agent multiplexers:

• Coder Mux — desktop/browser app focused on enterprise, with remote compute and plan/execute mode
• Emdash (YC W26) — desktop app with git worktree isolation
• Amux — a single Python file that wraps tmux, with a phone-accessible dashboard
• Claude Code native — shipped --worktree and --tmux flags in February 2026, plus Agent Teams as a research preview
• Cursor 2.0 — up to eight parallel agents with built-in worktree management

The sheer number of “Show HN” posts for agent multiplexers in early 2026 tells its own story. This is clearly a real workflow need, not a niche experiment.

cmux differentiates through what it calls “The Zen of cmux” — it positions itself as a primitive, not a solution. It gives you composable building blocks (terminal, browser, notifications, workspaces, splits, socket API) and explicitly avoids being prescriptive about how you orchestrate agents. The philosophy is that developers closest to their own codebases will discover optimal workflows faster than any product team could design top-down.

Whether that’s the right bet depends on how much orchestration you want to build yourself versus having it built for you.

Rough edges

cmux is young software — v0.62.0 as of this writing, launched in January 2026. Some things to know:

macOS only. There’s no Linux or Windows support. An unofficial community fork (snjax/cmux-linux) exists, but it’s not maintained by the cmux team. If you’re on Linux, this isn’t for you yet.

AGPL-3.0 licence. The copyleft requirement means that if you distribute cmux or provide it as a network service, you must disclose your source. For individual developers this is a non-issue. For enterprise environments with strict licensing policies, it might be a blocker. Competitors like Coder Mux use MIT.

Known bugs. The GitHub issue tracker has 400+ issues filed — a sign of both active engagement and genuine rough edges. Terminal pane rendering can break after closing splits. The embedded browser sometimes loses state when switching workspaces. Keyboard shortcuts occasionally stop responding after opening browser tabs.

No process persistence. Session restore brings back layout, working directories, scrollback, and browser history. But it doesn’t restore live processes. If you restart cmux, your Claude Code sessions, vim instances, and tmux sessions are gone. tmux still wins on session durability.

Getting started

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

Or grab the DMG from the releases page. To use the CLI from outside cmux terminals:

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

cmux works with any terminal-based agent — Claude Code, Codex, Gemini CLI, Aider, Goose, Amp, Kiro, and others. If it runs in a terminal, it runs in cmux.

Nick Schrock (creator of Dagster and GraphQL co-creator) put it simply after two hours with the app: “This is exactly the product I’ve been looking for.” Edward Grefenstette (Director of Research at Google DeepMind) said he’d been “using this all weekend and it’s amazing.”

The parallel agent workflow isn’t a novelty anymore — it’s becoming the default for anyone running AI coding assistants seriously. The open question isn’t whether you need a way to manage multiple agents, but which approach fits your style. cmux makes a strong case for the native terminal primitive.