   ░██                                             ░██       ░██            
   ░██                                                       ░██            
░████████ ░█████████████  ░██    ░██ ░██    ░██    ░██ ░████████  ░███████  
   ░██    ░██   ░██   ░██ ░██    ░██  ░██  ░██     ░██░██    ░██ ░██    ░██ 
   ░██    ░██   ░██   ░██ ░██    ░██   ░█████      ░██░██    ░██ ░█████████ 
   ░██    ░██   ░██   ░██ ░██   ░███  ░██  ░██     ░██░██   ░███ ░██        
    ░████ ░██   ░██   ░██  ░█████░██ ░██    ░██    ░██ ░█████░██  ░███████

The terminal that understands your agents.

2.8

Other tools rebuild the terminal to understand agents. tmux-ide teaches the terminal you already use to understand them. One command adds a native chrome to any tmux session — ground-truth agent status, notifications, and crash-proof restore. Zero lock-in.

Get started GitHub533

See who needs you

Adopt a session and the fleet gets a face: every agent's state, live, sorted so whoever is blocked rises to the top. The window below is the app's real sidebar component, running here.

tmux-ide — checkout-api

codex

claude code

cursor

Three agents, one project. codex hands the migration to claude for review — tmux-ide send claude "…" types the message straight into claude's pane. claude hits a call it can't make alone and goes blocked, which floats it to the top of the sidebar. Once you answer, it hands the tests to cursor. No message bus: the terminal is the bus.

Adopt in place

One command on the tmux you already run

tmux-ide adopt <session> drops a native chrome row onto any existing session — fleet tabs, live agent glyphs, home / switch / keys triggers. It's just tmux options: unadopt reverts it, and if tmux-ide ever dies your sessions are untouched plain tmux. No new terminal to learn, no lock-in.

Know your fleet

Ground-truth agent status, at a glance

Install the Claude Code integration and working / blocked / done come straight from the agent's own lifecycle — not a guess. Border chips show claude · working per pane; a toast fires on every attached client the moment an agent goes blocked or done. One glance tells you who needs you.

Survive anything

Rebuild the whole fleet after a crash

Continuous snapshots mean a tmux server death isn't a lost afternoon. tmux-ide restore rebuilds every session, window, layout, cwd, and title — and --resume-agents revives your Claude conversations from their recorded session ids. Nothing was lost.

Agents that task each other

Run a mixed fleet — Claude Code, codex, cursor, aider, anything — and let them coordinate. One agent tasks another by typing into its prompt; any agent can block until a teammate finishes. Claude Code reports automatically; everyone else self-reports with a one-line pane option.

checkout-api — coordination

Click a command to run it. send types the message into %2 and its hooks flip it to working; wait blocks until the pane prints the match. Three commands, one loop — how multi-agent teams work →

Every verb, one keystroke

⌘K opens the palette; the prefix twins open everything else — reliable under every keyboard protocol, with an ⌥ fast-path on top. One grammar, one theme.

⌘K — command palette

Click ⌘K, then type — try ses, agent, or layout. The rows and the ranking are the app's own; the highlighted characters are its matcher showing its work. (The real chord is ⌘K; on this page that belongs to the site search, so the demo opens on a click.)

prefix h · ⌥h

Home cockpit

Bare tmux-ide is the home screen — a fleet tree, detail pane, live preview, and rollup header. prefix h opens it as a popup over any session.

prefix b · ⌥b

Sidebar

A nav column you toggle in any session. The fleet, a keystroke away, without leaving your work.

prefix e g v

Floating panels

File explorer, git changes, and the config editor as popups over whatever you're doing. esc to close.

prefix u · right-click

Actions menu

Right-click any pane or the status bar for a native tmux menu at the pointer — the same actions, wherever you are.

prefix k · ⌥k

Cheat sheet

Every key on one iPadOS-style sheet. One interaction grammar everywhere: j/k move, enter opens, / filters, esc backs out, ? asks.

prefix + letter, always

Reliable keys

Prefix twins work under every keyboard protocol; the ⌥ fast-path is a one-key shortcut when your terminal allows it. One theme file colors chrome AND widgets.

Files and diffs, without leaving

F3 is a file explorer with a native editor; F4 is a diff you can stage from. The tree's hide/ignore rules, the diff's grouping, and the line colors below are the app's own code.

F3 — files

Click a folder to expand, a file to open. Toggle H and I — node_modules and .git stay hidden either way, because the app always ignores them.

F4 — diff

Real git status --porcelain, grouped into staged / unstaged / untracked by the app's parser. Pick a file, then [s stage] — it moves between groups, no shell required.

Everything else it does

The full surface, once over lightly. Each of these has a page in the docs.

The dock

A native tmux chrome row on any session: clickable fleet tabs with blocked / working / done / idle glyphs, plus home, switch, and keys triggers.

Two-layer detection

Authoritative status from Claude Code hooks; process-tree + evidence-tuned screen manifests as the fallback. User-overridable, debuggable with agent explain.

Self-report contract

Any agent can join the authority layer by writing one pane option: tmux set-option -p @agent_state working:$(date +%s). No integration required.

The who-needs-me loop

Toasts on any client when an agent goes blocked or done anywhere, optional macOS notifications, and per-pane border chips.

Event stream

tmux-ide events --follow is a JSONL stream of every agent-status transition — pipe it anywhere.

Coordination primitives

wait agent-status and wait output --match block until a session hits a status or a pane matches a regex. Scriptable synchronization.

Missions workspace preview

A durable project-scoped Missions board, history, and details surface for reviewing mission progress inside the current app.

Crash-proof restore

Continuous snapshots; tmux-ide restore rebuilds sessions, windows, layouts, cwds, and titles after a tmux server death.

Conversation revival

restore --resume-agents brings Claude conversations back via their recorded session ids (claude --resume).

Worktree flow

tmux-ide worktree create <branch> = a git worktree plus an adopted session inside it. Parallel agents on parallel branches.

Works over SSH

The chrome lives server-side, so it renders from any client — including SSH from a laptop or a phone.

ide.yml layouts

Optional: describe rows, panes, commands, and a sidebar in one file. tmux-ide init scaffolds it from your detected stack.

Programmatic CLI

--json on every command. status, inspect, events, and agent explain all speak structured output for scripting.

From zero to fleet in three commands

No migration, no new terminal. Adopt the sessions you already have.

step 01

Adopt

$ tmux-ide adopt work

Add the chrome to a session you already have. Fleet tabs, agent glyphs, and triggers appear. Nothing else changes.

step 02

Integrate

$ tmux-ide integration install claude

Hook Claude Code's lifecycle so working / blocked / done are ground truth. Any agent can self-report the same way.

step 03

Work

$ tmux-ide events --follow

Glance at the dock, get toasts when an agent needs you, and restore the whole fleet if the server ever dies.

Get started

Keep your terminal. Add the chrome. Adopt a session in seconds.

Get started What's new in 2.8