cmux Review 2026: Pricing, Warp and tmux Comparisons, and Tradeoffs

cmux is a native macOS terminal built for developers who run several command-line coding agents at once. It does not replace Claude Code, Codex, OpenCode, Gemini CLI, Aider, or another agent. It gives those tools a more visible operating surface: vertical workspaces, split panes, attention-aware notifications, an embedded browser, SSH support, and a programmable CLI.

That distinction is the key to evaluating it. If one terminal session is enough, cmux may be unnecessary. If several agents are working across branches, repos, or remote machines and you keep losing track of which one needs input, cmux addresses a specific workflow problem.

Short answer: cmux is worth evaluating for macOS developers who want a fast, terminal-first control surface for parallel coding agents without adopting an opinionated all-in-one agent platform. It is a poor fit if you need Windows or Linux desktop support, want AI included in the terminal subscription, or prefer a mature cross-platform multiplexer.

Quick Verdict

Question	cmux answer
Best for	macOS developers supervising several terminal coding agents or remote workspaces
Not ideal for	Windows and Linux desktop users, casual single-session workflows, or teams avoiding GPL software
Official site	cmux.com
Documentation	cmux docs
GitHub	manaflow-ai/cmux
Version checked	v0.64.19, released July 14, 2026
Install	Signed DMG or Homebrew cask on macOS
Core pricing	Free for local use; optional Pro and Team plans add cloud services
License	GPL-3.0-or-later, with a separate commercial license available
Public signal checked	About 24.5k GitHub stars, 2k forks, and same-day repository activity on July 15, 2026
Closest alternatives	Warp, tmux, Ghostty, Supacode, Orca, and Claude Squad

What Is cmux?

cmux is a native Swift and AppKit terminal for macOS. It uses libghostty for terminal rendering and reads a user's Ghostty configuration for themes, fonts, and colors, but it is a separate application rather than a Ghostty fork.

Its main idea is to make parallel terminal work legible. A workspace can show its working directory, git branch, pull request state, listening ports, and latest notification. Panes receive visual rings when a process needs attention, while a notification panel collects unread events across workspaces. This is more useful for agent work than a generic desktop alert that only says an agent is waiting.

cmux is still a terminal, so agent CLIs run without a special integration layer. The official site names Claude Code, Codex, OpenCode, Gemini CLI, Kiro, Aider, Goose, Amp, Cline, and Cursor Agent, but the broader rule is simpler: if the agent runs in a macOS shell, it can run in cmux.

Official Links and Installation

Use the primary sources for downloads and current behavior:

• Official site: cmux.com
• Getting started: cmux installation guide
• GitHub repository: manaflow-ai/cmux
• Releases: cmux releases on GitHub
• Pricing: cmux pricing
• License: GPL and commercial licensing terms

The recommended path is to download the signed DMG and move cmux into Applications. Homebrew users can install it with:

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

The stable app updates through Sparkle. The project also publishes a separate nightly build, but that channel is better for testing current development than for a dependable daily environment.

cmux is macOS-only today. The official site lists Linux, Windows, and Android as future platforms rather than current downloads. An iOS companion is available in beta through TestFlight for paid users, but it depends on a Mac running cmux; it is not a standalone replacement for the desktop app.

Where cmux Looks Strong

Parallel Agent Visibility

The clearest reason to use cmux is not raw terminal rendering. It is knowing what several agent sessions are doing. Vertical workspaces, split panes, notification rings, unread badges, branch metadata, and shortcuts for jumping to the latest unread item reduce the supervision cost of parallel work.

This is especially useful when each agent already has its own git worktree or repository checkout. cmux helps organize and observe those sessions, but it does not create a safe development process by itself. You still need branch isolation, review, tests, and sensible command permissions.

Terminal and Browser in One Programmable Surface

cmux can place a browser pane beside a terminal. Its socket API can navigate pages, inspect the DOM, click, type, read console or network activity, and take screenshots. That gives a terminal agent a path to verify a local web app without switching to a separate browser automation product.

The useful part is composability. The same CLI and Unix socket can create workspaces, open panes, send input, read screen contents, trigger notifications, and control the browser. Power users can build project-specific commands around those primitives rather than waiting for cmux to prescribe one workflow.

The security tradeoff is equally important. A programmable socket that can read terminal contents or drive a signed-in browser deserves careful access control. cmux documents restricted socket modes; shared Macs and sensitive browser profiles should use the narrowest mode that works.

Remote Work and Session Continuity

The cmux ssh workflow creates a workspace for a remote machine and can route browser panes through the remote network so a remote localhost remains reachable. cmux can also attach to remote tmux sessions, which makes the two tools complementary rather than strictly competitive.

Session restore brings back cmux-owned state such as windows, panes, working directories, browser URLs, and scrollback. It does not checkpoint arbitrary live processes. Long-running shells and agents still need their own resume support or a persistent layer such as tmux on the remote host.

cmux Pricing Reality

The local macOS terminal is free, and the source code is public under GPL-3.0-or-later. Running your own agent CLIs with your own subscriptions or API keys does not require a cmux subscription.

The optional paid plans fund services around the terminal:

• Free: the native terminal, local agents, local history, browser panes, SSH, automation, and community support;
• Pro: $30 per month, or $240 per year, with cloud-agent features, a model gateway, cloud history, the iOS beta, and 20 active compute-hours per month on the standard cloud VM;
• Team: $35 per user per month, adding centralized seats, pooled cloud hours, team rules, and unified billing;
• Enterprise: custom terms for requirements such as SSO, audit logs, and self-hosting.

Cloud VM overages are usage-based, so “Pro” is not a fixed unlimited compute plan. More importantly, cmux does not include the normal cost of Claude Code, Codex, Gemini, OpenCode providers, or other model services you run locally. Evaluate terminal cost, cloud compute, and model billing as separate layers.

Pricing and bundled cloud features can change faster than the open-source terminal. Check the official pricing page before budgeting.

Licensing and Company Use

cmux uses GPL-3.0-or-later for the public codebase. That is real open source, but it is a strong copyleft license rather than a permissive MIT or Apache license. Simply using the unmodified app internally is different from distributing a modified build or embedding the code in another product.

The repository also offers a separate commercial license for organizations that cannot comply with GPL terms. Companies planning to modify, redistribute, or integrate cmux should review the actual license and their intended use with counsel instead of assuming that a public GitHub repository removes licensing obligations.

cmux vs Warp

Warp is the better fit when you want a cross-platform terminal product with its own account-based AI experience, command blocks, and managed collaboration features. cmux is the better fit when you want a native macOS terminal focused on visible multitasking and programmability around agent CLIs you already use.

The practical decision is not “which terminal has AI?” cmux intentionally does not bundle one coding agent into the core local workflow. Choose it when agent neutrality and a composable socket API matter more than an integrated vendor assistant. Choose Warp when product polish across operating systems and built-in AI are higher priorities.

cmux vs tmux

tmux is a mature, cross-platform terminal multiplexer that runs inside another terminal, works well over SSH, and keeps processes alive independently of a desktop GUI. cmux is a native macOS application with vertical workspaces, graphical panes, notification context, an embedded browser, and macOS shortcuts.

cmux is easier to justify when the desktop experience and agent attention model are the main problem. tmux remains stronger when portability, server persistence, low overhead, and remote-first workflows matter most. Many developers will use both: cmux as the local interface and tmux on remote hosts.

cmux Alternatives

Ghostty: Choose Ghostty when you want a focused, fast terminal and do not need cmux's workspace metadata, embedded browser, and agent notification layer. cmux uses Ghostty's rendering library but adds a different product surface.

Supacode: Compare Supacode when you want a more opinionated desktop workspace around coding-agent sessions. cmux is closer to a programmable terminal primitive.

Orca or Claude Squad: These are better comparisons when the real requirement is orchestrating tasks and isolated worktrees, not replacing the terminal itself. They impose more workflow structure than cmux.

Paseo: Consider Paseo when cross-device supervision and remote access are central. cmux's iOS and cloud paths are growing, but its core identity remains a native macOS terminal.

Risks and Tradeoffs

• macOS lock-in: The desktop app is not currently available for Linux or Windows.
• Fast release cadence: v0.64.19 and active same-day development are healthy signals, but a rapidly changing pre-1.0 app can introduce regressions or workflow churn.
• Not an agent: cmux organizes other tools; it does not improve model quality or replace their subscriptions.
• Automation exposure: Terminal and browser control are powerful enough to require careful socket and credential boundaries.
• Copyleft licensing: GPL is workable for many users but needs review for redistribution and product integration.
• Extra workflow layer: If you only run one agent session, the sidebar, notifications, and automation surface may add more concepts than value.
• Vendor comparisons: The official comparison pages are useful feature inventories, but they are still written by cmux. Test the exact workflow that matters to you.

Who Should Use cmux?

Use cmux if:

• you work on macOS and run several terminal coding agents in parallel;
• you want attention-aware notifications instead of checking every pane manually;
• an embedded, scriptable browser would help agents verify web work;
• you use SSH and want local workspace organization around remote sessions;
• you prefer a terminal primitive that works with many agent vendors;
• you are comfortable with a fast-moving GPL project.

Skip cmux if:

• you need a native Windows or Linux desktop app;
• tmux already solves your multiplexing and persistence needs;
• you want one integrated AI subscription inside the terminal;
• you only run short, single-agent sessions;
• your organization cannot adopt GPL software and does not want a commercial license;
• browser and terminal automation create unacceptable local-security risk.

Bottom Line

cmux has a defensible place in the coding-agent stack because it solves an operator problem rather than pretending to be another model. Its strongest features—workspace metadata, attention-aware notifications, browser panes, SSH support, and a programmable socket—become valuable when several agents are active and the terminal itself turns into the coordination bottleneck.

The limitations are clear: macOS only, a young and fast-moving release line, separate model costs, and GPL obligations for some company uses. For the right terminal-first developer, those tradeoffs may be acceptable. For everyone else, Warp, tmux, Ghostty, or a more opinionated orchestrator may be the cleaner choice.

Start with the cmux tool page, verify the latest official documentation and GitHub release, then test it with a small non-critical workflow before moving every agent session into it.