The Evolution Direction of Terminals Has Changed: Some Are Rendering Pixels, Some Are Building Command Centers for AI

Have you ever had a moment like this—running five or six Claude Code sessions simultaneously, and the macOS notification bar pops up every two minutes saying "Claude is waiting for your input." You click in, only to find that it's not this one waiting for you. You flip through all six tabs and finally find the one that's actually stuck.

This isn't just your problem. When AI coding assistants go from "occasional use" to "running five or six in parallel," traditional terminals expose a fundamental flaw: they don't know what your agent is doing, let alone which one is waiting for you.

For the past 40 years, the direction of terminal evolution has been "faster rendering, more colors, more flexible split screens." But the AI agent era introduces a new requirement—what you need is not just a typing window, but a command center that can see agent status.

cmux, with 23.6k stars, is the first step in this direction.

A Project Born from Notification Pain

The pain point of cmux author lawrencechen is extremely specific: He runs a large number of Claude Code and Codex sessions in Ghostty. macOS native notifications only ever say "Claude is waiting for your input," with no context; when tabs are opened too many, even the titles can't be fully seen.

He tried several coding orchestrators, but they were mostly Electron or Tauri wrappers—slow to open, high memory usage, and these GUI orchestrators force you to follow their workflow, losing terminal flexibility.

So he chose a hard path: Build a native macOS application from scratch using Swift + AppKit, reuse libghostty (Ghostty's rendering engine) for terminal rendering, and add a sidebar and notification system on top.

The result of this choice is—fast startup, low memory, GPU-accelerated rendering, and your existing Ghostty configuration (themes, fonts, color schemes) can be read directly with zero migration cost.

Notification Ring: Turning Agent Waiting into a Visual Signal

The core invention of cmux is the notification ring.

When an agent needs your action, the edge of the corresponding terminal split screen glows with a blue ring, and the sidebar tab lights up. You don't need to flip through tabs; a glance at the sidebar tells you which agent is stuck. Cmd+Shift+U jumps directly to the most recent unread notification, without switching one by one.

What problem does this design solve? It transforms "agent is waiting for me" from information that needs active searching into a passively received visual signal.

Imagine running 5 Claude Code agents simultaneously: In a traditional terminal, you have to switch tabs one by one to see which one is stuck; in cmux, the sidebar directly tells you—the third tab's agent is waiting for you to confirm a file modification.

The notification system also supports the CLI command cmux notify, which you can hook into any agent—not just Claude Code, but also OpenCode, custom scripts, etc.

Sidebar: A Qualitative Leap in Information Density

What are traditional terminal tabs? A line of truncated text, often cut off. With ten tabs open, you can only see "claude", "claude", "clau…".

cmux's vertical sidebar turns each tab into an information card, displaying:

• Git branch name
• Associated PR number and status
• Working directory
• Listening ports (e.g., localhost:3000)
• Latest notification text

With ten agents running in parallel, a glance at the sidebar tells you what each is doing, where it's stuck, and which branch it's running on. This isn't "prettier tabs," but an information architecture upgrade from "tabs" to "dashboard".

Built-in Browser: The Agent's Eyes

At first glance, this feature might seem like "why put a browser in a terminal," but think about the real scenario:

You're running Claude Code to modify frontend code, and the dev server is running on localhost:3000. In a traditional workflow, you have to switch back and forth between the terminal and browser—edit code, switch to browser to see the effect, then switch back.

cmux's approach is to open a browser panel as a split screen right next to the terminal, and this browser is programmable—ported from Vercel's agent-browser project. The agent can screenshot the accessibility tree, get element references, click, fill forms, execute JavaScript, and read console logs and network requests.

This means Claude Code can directly verify its own changes on your development server without you manually refreshing the browser.

The browser also supports importing cookies and history from 20+ browsers like Chrome, Firefox, and Arc, so it opens with your login state.

One Command to Launch an Agent Team

cmux claude-teams

One command launches Claude Code's teammate mode, where each teammate is automatically created as a native split screen with metadata and notifications in the sidebar. No tmux, no manual split screen configuration.

SSH is also optimized: cmux ssh user@remote creates a remote workspace, the browser panel routes through the remote network, localhost is directly accessible, and dragging images can be uploaded via scp.

Truly Native, Not a Shell

The word "native" is used too much, but cmux is truly native—Swift + AppKit, not Electron, not Tauri, not a webview shell.

This means:

• Startup speed comparable to the system terminal
• Memory footprint much lower than Electron-based terminals
• Auto-save session state on exit; reopening restores layout, working directory, scroll history, and even agent sessions

But It's Not Perfect

Fair to say, cmux has clear limitations:

macOS only. Linux and Windows users are directly out. The author also acknowledges on HN that cmux's design centers on local macOS development, and remote SSH scenarios are not the primary goal. If you heavily rely on remote terminals, cmux can't help much currently.

Still in rapid iteration, with bugs. The community has user feedback like "Looks really cool, but it's a buggy mess." Sidebar font size cannot be adjusted independently, which is unfriendly for users with poor eyesight. Keyboard shortcuts conflict with Ghostty's configuration, and some mappings are not respected.

It's not a coding agent itself. cmux is workflow infrastructure; its value depends on whether you use agent CLI. If you only occasionally chat with Claude Code, cmux's notification system and sidebar are overkill.

Inflection Point for the Terminal Category

cmux's significance is not about how perfect it is, but that it marks an inflection point for the category:

Terminals are evolving from "text renderers" to "agent workflow operating systems."

In the past, the competitive dimensions of terminals were rendering performance (GPU acceleration) and customizability (themes, fonts). But when developers start running multiple AI agents simultaneously, a new requirement dimension emerges—state awareness and attention management.

This trend is not unique to cmux. Warp introduced "Agentic Terminal," Zellij added floating panels, and the market has seen agent orchestrators like Conductor and Superset. But cmux takes a different path: It doesn't invent a new workflow; it adds a perception layer on top of your existing terminal workflow—letting you see agent states instead of being overwhelmed by agent notifications.

The iTerm2 author solved "terminals aren't easy to use" 15 years ago, and the Ghostty author solved "terminals aren't fast enough" 2 years ago. cmux tries to solve "terminals can't see what AI is doing."

If you run more than 3 AI coding agents simultaneously on macOS, cmux is worth the 10 minutes to try.

GitHub: https://github.com/manaflow-ai/cmux

Promotional links:

• OpenModel https://www.openmodel.ai?ref=wYOxNxlv
• Stepfun https://platform.stepfun.com?invite_code=PQCZLBNK
• Agnes AI https://platform.agnes-ai.com/ (1M context + 4K image generation + video all free, API: apihub.agnes-ai.com/v1)