On this page
  1. Overview
  2. cmux
  3. herdr
  4. Warp
  5. amux
  6. Others
  7. mosh
  8. What this means for cotty
  9. Sources
  10. Not covered

Which products already serve people who run many agents in terminals, and what do they leave open? The space is crowded. Four things are still missing: structured records at the level of a command, local policy and redaction, structured approval, and sync over poor networks.

A later note, Six capabilities across terminals, covers more products and corrects the second of these four points.

Reliability labels:

  • [official]: from the project’s own site or repository.
  • [vendor]: from a comparison article written by a competitor. It favors its own product.
  • [third party]: from a blog or a review. Not verified.

Versions and dates change fast. Check the official source before relying on them.

Overview

The products fall into three groups, plus infrastructure.

Group Product In one sentence
Native terminal app cmux A native macOS terminal built on libghostty, made for running many agents in parallel
Warp An open-source terminal with its own agent CLI. Its focus has moved to the cloud “Warp Factories”
crystl A commercial macOS terminal with floating approval cards [third party]
Multiplexer or runtime herdr An agent-aware multiplexer in Rust that has grown a runtime, a desktop app and a mobile app
amux A web panel, a REST API and phone push notifications on top of tmux
dmux, workmux, ittybitty CLI tools that combine git worktrees with tmux [third party]
Desktop orchestration app, closer to an IDE Paradev (formerly Superset), Emdash, Orca One worktree per task, a diff viewer, a built-in browser [third party]
Infrastructure tmux, mosh Sessions that persist. A remote terminal for poor networks

cmux

[official: cmux.com, GitHub manaflow-ai/cmux]

  • Form. A native macOS terminal app (Swift and AppKit) built on libghostty. It is not a fork of Ghostty.

  • Platforms. macOS 14 and later, “macOS only, for now”. A companion iOS app is in testing on TestFlight.

  • License. The app is GPL-3.0-or-later. The server components are BSL 1.1 according to the repository description (not verified).

  • Main features.

    • A pane lights up when its agent is waiting for you (the notification ring).
    • Vertical tabs show the git branch, pull request status, ports and the latest notification.
    • A scriptable built-in WebKit browser pane.
    • A CLI and a Unix socket API.
    • Managed SSH and remote tmux, in beta.
    • Session restore: layout, directories, scrollback, and agent sessions resumed by a saved ID. Processes are not kept.
  • State detection. It does not parse the screen. Notifications come from OSC 9/99/777, the cmux notify command, and agent hooks installed by cmux hooks setup.

  • Security.

    • Commands defined in a project’s .cmux/cmux.json must be trusted before they run.
    • When saving restore information, it drops sensitive environment variables such as tokens, passwords and API keys.
    • Socket access has three modes: off, cmuxOnly and allowAll.

    These are access control and not storing secrets. They are not output redaction.

  • Pricing. The core is free. Pro includes early access on iOS, cloud VMs and “cmux AI”.

  • Note. Some third-party articles say cmux has no remote access and no API. They are out of date.

herdr

[official: herdr.dev, herdr.dev/core, GitHub herdrdev/herdr]

  • Written in Rust, Apache-2.0, about 52,000 stars on its GitHub page in November 2026.
  • It is a family of products:
    • Herdr TUI, the first product.
      • One Rust binary: a tmux-like multiplexer that runs inside an existing terminal. It has a background server; ctrl+b q detaches and herdr reattaches.
      • Three levels of organization: a space per repository, a tab per task, and panes.
      • Each pane shows a state: working, blocked or idle.
        • Detection, according to third parties: first the foreground process, then “screen rules” matched against the bottom of the screen.
        • Optional hooks are installed with herdr integration install <agent>.
        • herdr agent explain shows which rule matched, and herdr agent wait --until blocked waits for a state.
      • A CLI and a socket API: an agent can open panes, message other agents, and wait until another agent is really blocked.
      • One window manages several SSH machines (according to third parties, version 0.9, September 2026).
      • Layout is restored after a restart, and supported agents continue their last conversation. The original processes are not kept.
      • Pane history is off by default, because it could record secrets [third party].
    • herdr-core (hc).
      • “A small server on your machine”. The project says it “draws nothing and guesses nothing”.
      • State comes only from what programs report through OSC 7501, the Program Status Protocol: “No screen scraping, no list of known agents”. Example: printf '\e]7501;state=blocked:app=my-agent\e\\'.
      • Commands: hc run [--bg] [--name] CMD, hc ls, hc attach, hc send NAME "text", hc wait, hc read --lines N, hc machine add, hc run --on MACHINE, hc schema (prints OpenRPC), and hc --skill (a manual for agents).
      • A sub-agent hangs under the agent that started it and stops with it.
    • Desktop app (according to third parties quoting the official announcement, 2026-10-29).
      • Built on herdr-core. It does not share agents with the TUI.
      • Layout, sidebar, keys and theme are plain text files in ~/.config/herdr-app, which an agent can edit directly.
    • Mobile app (according to third parties, 2026-11-09).
      • iPhone, iPad and Android.
      • The inbox is sorted by how much each item needs you. A left swipe sends Esc, and text or speech can be entered.
      • It connects over SSH, and Tailscale also works: “No account, and your terminals never pass through us”.
  • Overlap with cotty. It already has an agent interface, waiting, several machines and a mobile app.
  • What it does not have. Structured records at the level of a command, including exit codes. Local policy and output redaction. Structured approval that states its impact. State sync over poor networks.

Warp

[official: warp.dev]

  • The top of its home page now reads “Warp Factories: Open infrastructure for software factories”. It runs in the cloud and charges by agent run.
  • Warp Terminal: “A modern terminal for agentic coding”, now open source. The client is AGPL-3.0 [third party].
  • Warp Agent CLI: a coding agent that works in any terminal.
  • Platforms: Mac, Linux and Windows.
  • Approval gates, secrets injected as environment variables only at run time, and central permission and agent governance are all in the cloud Factories, not in the local terminal.
  • On a phone, agents can be “watched, steered, and handed off”.

amux

[vendor: amux.io. The product information is also on its site]

  • One Rust binary with SQLite. A local HTTPS service manages tmux sessions, with a web panel and a REST API.
  • macOS, Linux and cloud VMs. A PWA and an iOS app.
  • MIT with the Commons Clause.
  • Features:
    • It resumes automatically when a usage limit lifts, and brings workers up after a macOS restart.
    • It pushes a notification when an agent is stuck.
    • A board with quality gates.
    • amux send lets agents message each other.
    • Optional isolation by worktree.
    • Cost statistics per session.
  • The hosted amux Cloud starts at 39 US dollars a month.

Others

All of these are [third party] and not verified.

  • Paradev (formerly Superset): a desktop app with cloud workspaces, Elastic License 2.0, one worktree per task, a diff viewer and a built-in browser. Pro supports automation triggered from Slack, Linear, Sentry and GitHub. Another article describes Superset as “a terminal overlay with agent detection and output summaries”. The two descriptions conflict.
  • Emdash: a desktop app, Apache-2.0, one worktree per task, remote projects over SSH.
  • Orca (Stably AI): an MIT desktop app, one worktree per agent, companion iOS and Android apps in testing.
  • Xum (formerly Mux, by Coder): AGPL-3.0, desktop and server modes, a web layout that works on phones, and its own agent loop.
  • crystl: a commercial macOS terminal with floating approval cards and an iPhone app. Paid plans go through an encrypted relay.
  • Termdock: Electron, with CPU and memory shown per session.
  • Beam: Electron, xterm.js with node-pty. It states that it does not detect agent state [vendor].
  • Chloe: a terminal replacement centered on agents, with a conversation view, session recording and messages between agents.

mosh

[official: mosh.org, GitHub mobile-shell/mosh]

  • An MIT project from 2012. The latest version is 1.4.0, from 2022, and it has moved slowly since.
  • How it works. It logs in with ssh and starts mosh-server on the remote side. After that it uses UDP (ports 60000 to 61000 by default) with AES-OCB encryption.
  • The core idea, the SSP protocol.
    • The server runs a terminal emulator itself. It syncs only the differences in screen state and does not forward the byte stream. Intermediate frames can be skipped.
    • So Ctrl+C takes effect at once, even while output floods the screen.
  • Roaming. The connection survives when the client changes its IP address or the computer sleeps and wakes.
  • Local predictive echo. At high latency it shows what you type first, and underlines what the server has not yet confirmed.
  • Limits. No scrollback (people usually run tmux inside it), no port forwarding or agent forwarding, UDP must be open, and mosh must be installed on the remote side.
  • Why it matters here. It applies “what a terminal shows is the state of a character grid” to network transport. It is the prototype for sync over poor networks.

What this means for cotty

Four things are missing, according to the material above:

  1. Structured records at the level of a command. No product gives agents a structured record of each command: command line, directory, time, exit code, output. herdr’s wait waits for an agent state, not for the end of a command.
  2. Local policy and output redaction. Nobody has it. cmux only avoids saving sensitive environment variables. Warp’s approval and secrets are in the cloud.
  3. Structured approval. On phones, most products offer viewing plus sending keys or text. None has approval that states its impact (diff, files, commands, risk), and none can save a decision as a rule.
  4. Sync over poor networks. Remote access relies on SSH or tmux. Nobody syncs state in the manner of mosh, let alone with scrollback and structured command blocks.

The product consequences are in Positioning.

Sources

Not covered

  • Claude Squad, and Zed’s ACP (Agent Client Protocol).
  • Wave Terminal, Zellij and the AI features of iTerm2. The later note covers them.
  • Earendil RFC 0031, Terminal Multiplexers, on the problems agents meet in tmux and Zellij: keyboard input, paste, capability negotiation and escape-sequence passthrough.