Cmux Terminal Multiplexer
Give Claude Code and other agents a programmable terminal workspace—splits, command I/O, headless browser control, and visible status—for parallel autonomous work.
Overview
cmux-terminal-multiplexer is an agent skill most often used in Build (also Ship, Operate) that exposes splits, CLI/socket control, and headless browser automation for coordinated agent workspaces.
Install
npx skills add https://github.com/aradotso/trending-skills --skill cmux-terminal-multiplexerWhat is this skill?
- Programmable socket API and CLI: identify context, list workspaces, open splits, send commands, capture output
- Full Playwright-equivalent headless Chromium browser automation with snapshot-based element refs (no CSS selectors)
- Status sidebar with progress bars, log lines, and icon badges plus native OS notifications from workflows
- Agent team coordination—parallel subagents each get their own visible terminal split
- Documented triggers include cmux browser automation, split setup, and send-command flows
Adoption & trust: 1.3k installs on skills.sh; 31 GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent cannot reliably run parallel shells, stream status to you, or drive a real browser from one programmable terminal workspace.
Who is it for?
Indie builders running Claude Code or similar agents on multi-step repos who want terminal plus browser automation without juggling separate tmux and Playwright setups.
Skip if: Simple one-shot edits with no local terminal, teams forbidden from headless browsers or shell automation, or workflows that only need a static code generator.
When should I use this skill?
Triggers include: use cmux to open a split; cmux browser automation; open a terminal split with cmux; control browser with cmux; cmux agent workspace coordination; set up cmux splits for parallel work; cmux send command
What do I get? / Deliverables
You get splits, command delivery, captured output, snapshot-based browser actions, and sidebar or OS signals so agents—and you—can run parallel work with visible coordination.
- Configured cmux workspace with terminal splits and optional browser surface
- Captured command output and snapshot-driven browser interaction traces usable by the agent
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
cmux is primarily agent infrastructure you configure while building agentic dev setups, though the same tooling supports test and ship automation. Terminal multiplexing, socket API, and agent team splits are core agent-tooling concerns, not a single app feature.
Where it fits
Open stacked cmux splits so a lead agent and two subagents each run installs and tests in dedicated panes.
Drive headless Chromium via cmux snapshot refs to click through a new UI flow while another pane runs the dev server.
Automate browser regression checks from the agent before merge using cmux send-command and capture output.
Keep a long-running agent session in cmux with sidebar progress and OS notifications when a deploy script finishes.
Spin a quick prototype environment with browser plus server splits to demo a clickable MVP locally.
How it compares
Agent-first multiplexer with a socket API and built-in browser surface—broader than vanilla tmux and more terminal-native than driving Chrome only through a standalone MCP browser server.
Common Questions / FAQ
Who is cmux-terminal-multiplexer for?
Solo builders and small agent teams who want Claude Code-style agents to open splits, send terminal commands, automate Chromium, and report progress in a visible workspace.
When should I use cmux-terminal-multiplexer?
Use it in Build when setting up agent workspaces and parallel splits; in Ship when running browser or terminal-backed verification; and in Operate when agents need long-running monitored sessions with notifications.
Is cmux-terminal-multiplexer safe to install?
Check the Security Audits panel on this Prism page; the skill implies shell execution, browser control, and local process access—review permissions and isolate machines you do not trust with autonomous command injection.
SKILL.md
READMESKILL.md - Cmux Terminal Multiplexer
# cmux — AI-Native Terminal Multiplexer > Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection cmux is a terminal multiplexer with a programmable socket API designed for AI coding agents. It provides full Playwright-equivalent browser automation, real-time terminal split management, sidebar status reporting, and agent team coordination — all via a simple CLI. --- ## What cmux Does - **Terminal splits** — create side-by-side or stacked panes, send commands, capture output - **Browser automation** — full headless Chromium with snapshot-based element refs (no CSS selectors) - **Status sidebar** — live progress bars, log messages, and icon badges visible to the user - **Notifications** — native OS notifications from agent workflows - **Agent teams** — coordinate parallel subagents, each with their own visible split --- ## Orient Yourself ```bash cmux identify --json # current window/workspace/pane/surface context cmux list-panes # all panes in current workspace cmux list-pane-surfaces --pane pane:1 # surfaces within a pane cmux list-workspaces # all workspaces (tabs) in current window ``` Environment variables set automatically: - `$CMUX_SURFACE_ID` — your current surface ref - `$CMUX_WORKSPACE_ID` — your current workspace ref Handles use short refs: `surface:N`, `pane:N`, `workspace:N`, `window:N`. --- ## Terminal Splits ### Create splits ```bash cmux --json new-split right # side-by-side (preferred for parallel work) cmux --json new-split down # stacked (good for logs) ``` Always capture the returned `surface_ref`: ```bash WORKER=$(cmux --json new-split right | python3 -c "import sys,json; print(json.load(sys.stdin)['surface_ref'])") ``` ### Send commands and read output ```bash cmux send-surface --surface surface:22 "npm run build\n" cmux capture-pane --surface surface:22 # current screen cmux capture-pane --surface surface:22 --scrollback # with full history cmux send-key-surface --surface surface:22 ctrl-c # send key cmux send-key-surface --surface surface:22 enter ``` **Golden rule: never steal focus.** Always use `--surface` targeting. ### Worker split pattern ```bash WORKER=$(cmux --json new-split right | python3 -c "import sys,json; print(json.load(sys.stdin)['surface_ref'])") cmux send-surface --surface "$WORKER" "make test 2>&1; echo EXIT_CODE=\$?\n" sleep 3 cmux capture-pane --surface "$WORKER" cmux close-surface --surface "$WORKER" # clean up when done ``` ### Pane management ```bash cmux focus-pane --pane pane:2 cmux close-surface --surface surface:22 cmux swap-pane --pane pane:1 --target-pane pane:2 cmux move-surface --surface surface:7 --pane pane:2 --focus true cmux reorder-surface --surface surface:7 --before surface:3 ``` --- ## Browser Automation cmux embeds a full headless Chromium engine with a Playwright-style API. No external Chrome required. Every command targets a browser surface by ref. ### Workflow pattern ``` navigate → wait for load → snapshot --interactive → act with refs → re-snapshot ``` ### Open and navigate ```bash cmux --json browser open https://example.com # opens browser split, returns surface ref cmux browser surface:23 goto https://other.com cmux browser surface:23 back cmux browser surface:23 forward cmux browser surface:23 reload cmux browser surface:23 get url cmux browser surface:23 get title ``` Capture the surface ref: ```bash BROWSER=$(cmux --json bro