TUICommander

The IDE that understands AI agents.
Run parallel agents on isolated branches with full observability.

Website • Download • Nightly • All Features • Plugins • Plugin API • Docs

---

---

The problem

You're running Claude Code in one terminal, Aider in another, Codex in a third. One hit a rate limit 10 minutes ago and you didn't notice. Another is waiting for a Y/N confirmation. You switch between windows and still lose track.

The more sessions you run, the worse it gets. The tooling doesn't understand what's happening inside the terminal.

The solution

TUICommander is an AI-native IDE — designed from the ground up for multi-agent development. Agents, code, diffs, PRs, CI status, and usage analytics live in one window. No context switching. No lost threads.

AI-native means the agents are not an afterthought. Rate limit detection, question recognition, session-aware resume, and usage tracking are core — not plugins.

---

What makes it different

Run many AI sessions in parallel

Launch Claude Code on five branches at once — or mix agents. Each session runs in its own Git worktree — no context collision, no stash conflicts, no "which terminal was that?" moments.

• Up to 50 terminal sessions running simultaneously
• Each session works on its own isolated copy of the repo
• Activity dashboard showing every session at a glance

Agent observability — not just terminals

TUICommander auto-detects 11 AI coding agents (Claude Code, Codex CLI, Aider, Gemini CLI, Amp, Cursor Agent, OpenCode, Droid, Goose, Grok, pi) and understands what they're doing:

• Rate limit detection — Provider-specific patterns with countdown timers per session.
• Question detection — Y/N prompts, numbered options, inquirer-style menus. Tab indicator, notification sound, keyboard overlay.
• Usage tracking — Provider-aware Claude, Codex, and Grok limits with color-coded thresholds and native dashboards; Gemini remains terminal-detection only until it exposes a stable account quota API.
• Activity dashboard — Every session at a glance: agent type, status (working / waiting / rate-limited / idle), last activity.
• Session-aware resume — Auto-discovers agent session IDs from disk (Claude Code, Gemini CLI, Codex CLI, Grok). Resume exactly where you left off.

No other tool knows that your agent is stuck.

Progress — what happened while you were away

Every project gets an append-only journal. Agents write two kinds of entry — done when the work they announced is finished, blocked when they cannot continue without you — and TUICommander writes a third, intent, read off the agent's own intent: marker, so an agent that never calls the tool still leaves a trail of what it set out to do.

• MCP progress tool — type, text, and an optional free-text step. One call appends the entry and raises the toast.
• Toolbar bell with the number of entries that arrived since your last visit; the dialog freezes the last-visit divider so it never moves under the line you are reading.
• Blocked entries in red, a blocked-only filter, per-entry deletion. No pause, no clear, no correction — you read it and delete what you do not want to keep.
• Nothing is written inside your repositories — one SQLite database in TUICommander's configuration directory, with the project as a column. No .tuic directory, nothing for Git to ignore, no file-watcher event.
• A worktree files under its parent project, so a repository and its worktrees show one history.
• One global switch plus a per-agent override; off globally removes the tool from every agent's tool list.

Project Progress →

Git worktrees, fully managed

Click a branch in the sidebar. TUICommander auto-creates a git worktree — a fully isolated copy of the repo. The terminal opens inside it. Switch to another branch: your previous terminals are preserved. Switch back: they're exactly as you left them.

• Automatic worktree creation on branch click
• Worktree Manager — PR status, dirty file counts, last commit at a glance
• Post-merge cleanup dialog — delete branch, archive worktree in one click
• Configurable base branch, setup scripts, auto-fetch intervals

See what your agents changed — without leaving

The feedback loop happens in the same window:

• Git Panel — Staging, inline commit, blame with age heatmap, canvas commit graph, stashes, branches with ahead/behind counts.
• Diff views — Side-by-side, unified, or scroll-all-files. Word-level highlighting, hunk and line-level restore.
• PR management — Merge via GitHub API with auto-detected merge method. Post-merge cleanup.
• Multiple GitHub accounts — Run more than one github.com login and any number of GitHub Enterprise Server accounts side by side. Bind each repo to the account that monitors it; ambiguous repos ask instead of guessing. Every account polls independently — a rate limit on one never stalls the others.
• GitHub Issues — Filter by assigned/created/mentioned, labels with colors, close/reopen.
• CI Auto-Heal — When CI fails, TUICommander fetches failure logs and injects them into the agent for automatic fix.
• Built-in code editor — Syntax highlighting, find/replace, disk conflict detection, a VS Code-style change-overview ruler, and a Cmd/Ctrl+hover go-to-definition affordance.
• File browser — Directory tree, content search (grep), git status indicators.

AI Chat — ego over ACP

TUICommander used to carry its own LLM client and autonomous agent loop. Both were removed: it stores no model API key and makes no provider HTTP call. Intelligence comes from ego over ACP, while TUICommander stays the environment — terminals, repositories and the MCP server that agents drive.

The panel streams ego conversations, reasoning, tool calls, plans, permissions, and elicitation forms. Sessions belong to repositories rather than terminal tabs, so a turn keeps running while you move elsewhere. See docs/user-guide/ai-chat.md.

MCP Proxy Hub — one connection for all your tools

Aggregate all your MCP servers into a single endpoint. Claude Code, Cursor, VS Code — each agent connects once and gets access to every upstream tool.

• Auto-configures Claude Code, Cursor, Windsurf, VS Code, Zed, Amp, Gemini, Codex, Grok, OpenCode, Droid, Goose, and pi
• Circuit breakers, health checks, hot-reload per upstream
• Credential management via OS keyring, OAuth 2.1 support
• Tool filtering: whitelist or blacklist per upstream server

Control from anywhere

A mobile companion PWA lets you monitor agents from your phone, answer questions with one tap, and track rate limits in real time.

• QR code scan for instant LAN connection
• Tailscale auto-HTTPS or E2E-encrypted cloud relay — no VPN or port forwarding
• Live WebSocket output, suggest follow-up chips, slash menu

tuic-remote headless daemon (beta) — Run the backend where the code is: a Linux build host, a server, any machine with no desktop environment. Pure Rust binary, no Tauri and no GUI, serving the same HTTP/WebSocket API as the desktop app. Point a desktop TUICommander at it and its repositories, terminals and agents behave like local ones.

• Published for Linux x64/ARM64, macOS ARM and Windows x64 — together with tuic-bridge, which gives the agents running on that machine the full tuicommander MCP tool surface
• Every TCP request is authenticated: the headless build has no loopback bypass, so an SSH tunnel does not make the daemon local. GET /health is the only unauthenticated route
• --instance <id> for a fully isolated configuration directory and keyring vault
• Default port 9877 (TUIC_PORT to override), optional manual TLS

Remote Access → • tuic-remote setup →

Agents that coordinate

Agent Teams — Claude Code's sub-agents run as native TUICommander tabs instead of tmux panes. Full session awareness, output parsing, and question detection for each sub-agent.

Inter-agent messaging — When multiple agents work in parallel, they discover peers, send messages, and receive push notifications through TUICommander as the coordination hub.

Automate repetitive workflows

29 built-in Smart Prompts turn common tasks into one-click operations: Smart Commit, Review Changes, Create PR, Fix CI, and more. Context variables like branch, diff, and PR data are resolved automatically.

• Inject mode (PTY write), headless mode (subprocess), or shell script mode (direct execution)
• 35 context variables auto-resolved from git, GitHub, terminal, and file context
• Create your own prompts with the same variable system

Talk to your agents

On-device speech-to-text powered by whisper-rs. No cloud service, no API keys, no data leaving your machine.

• GPU-accelerated on macOS (Metal) and Windows (Vulkan), CPU on Linux (optional CUDA/Vulkan)
• Push-to-talk hotkey — text injected into the active terminal
• 4 model sizes from Small (488 MB) to Large V2 (3 GB), incl. large-v3-turbo (1.6 GB)

Extend everything

Plugin system — Obsidian-style plugins with hot reload and a community registry:

• 5 capability tiers from read-only watchers to scoped Tauri invoke
• TUIC SDK v1.0: tuic.activeRepo, tuic.toast, tuic.onRepoChange and more
• Terminal output watchers with regex triggers
• Status bar tickers, custom panels, notification contributions
• Browse and install with one click

Browse the plugin registry → • Plugin Authoring Guide →

Built to be scripted — CLI, HTTP, and MCP control surface

TUICommander isn't a black box. Everything you click, you can also drive from a script, another tool, or an AI agent.

• tuic CLI companion — Open files with cursor goto (tuic src/main.rs:42:8), manage sessions (ls / new / kill / send), orchestrate agents (spawn / ls / send), plus a tmux-compatibility alias mode. Installs from Settings, auto-updates on launch.
• HTTP API — REST + WebSocket + SSE on a local port: list/create/close sessions, stream live output, spawn agents, read terminal grids and scrollback, query process CPU/RSS. Script TUIC from anything that can hit a socket.
• MCP control surface — TUIC is itself an MCP server. Connected agents get session, agent, repo, ui, and progress tools — including drive_agent (atomic send → wait-for-idle → read) and delta cursors that return only new output. (Distinct from the MCP Proxy Hub above, which aggregates your upstream servers.)
• Custom "Open in…" launchers — Define your own editor/tool commands with placeholder tokens: {file}, {repo}, {fileDir}, {cwd}, {home}, {line}, {column}. iTerm2, Tower, and the full JetBrains family ship built in.

CLI guide → • HTTP API → • MCP server →

---

How it compares

Capability	Ghostty / Kitty	Warp	Cursor IDE	Claude Desktop	TUICommander
Terminal sessions	Yes	Yes	Yes	No	Yes (50)
AI coding agents	No	Partial	Built-in	Built-in	Any agent (10 detected)
Parallel agents	No	No	Limited	No	Unlimited
Git worktree orchestration	No	No	No	No	Automatic
Agent observability	No	No	No	No	Real-time
Global Workspace	No	No	Yes	No	Multi-repo
Usage dashboard	No	No	No	Basic	Full (heatmap, per-project)
Remote access (phone/tablet)	No	No	No	Mobile app	PWA + E2E relay
Voice dictation	No	No	Extension	Built-in	Local Whisper
MCP Proxy Hub	No	No	No	No	Built-in
Plugin system	No	No	Extensions	No	Hot reload + SDK
GitHub Issues & PR management	No	No	Extension	No	Built-in
Multi-account & Enterprise GitHub	No	No	No	No	github.com + GHE
Built-in AI Chat	No	Built-in	Built-in	Built-in	ego over ACP
CI Auto-Heal	No	No	No	No	Built-in

---

Terminal features — 50 sessions, splits, detach, find, persistence

• Up to 50 concurrent PTY sessions, each with independent zoom (8–32px)
• Split panes: vertical (Cmd+\) or horizontal (Cmd+Alt+\), up to 4 panes, drag-resize
• Detachable tabs: float any terminal into its own OS window, re-attaches on close
• Find in terminal (Cmd+F): regex, case-sensitive, whole word, match navigation
• Cross-terminal search: type ~ in command palette to search all open terminal buffers
• Session persistence: terminals survive restarts with lazy restore on branch click
• Tab management: reorder by drag, rename by double-click, reopen last 10 closed tabs
• Tab status dots: idle, busy, done, unseen, question, error
• Copy on select, configurable bell (visual/sound/both), scroll shortcuts
• International keyboard support, Kitty keyboard protocol
• 11 bundled monospace fonts (JetBrains Mono, Fira Code, Hack, Cascadia Code, and more)

Git integration — Worktrees, Git Panel, PR management

• Auto-create worktrees per branch with configurable base branch and setup scripts
• Worktree Manager (Cmd+Shift+W): all worktrees across all repos, orphan detection, batch operations
• Git Panel (Cmd+Shift+D): staging, commit, log with canvas commit graph, stashes, branches, blame with age heatmap
• PR management: merge via GitHub API, auto-detect merge method, post-merge cleanup dialog
• Multi-account GitHub: multiple github.com logins + GitHub Enterprise Server accounts (PAT), per-repo account bindings with an ambiguity chooser, isolated per-account polling/rate-limits/circuit-breaker
• GitHub Issues: filter by assigned/created/mentioned, labels with colors, close/reopen
• Auto-delete branch on PR close, CI Auto-Heal, PR notifications
• Repository groups: named, colored, collapsible, drag-and-drop reordering
• Park repos: temporarily hide repos you're not using
• Quick branch switcher: hold Cmd+Ctrl, press 1-9 to switch instantly
• Auto-fetch on configurable interval

Productivity — Smart Prompts, palette, keybindings, dictation

• Smart Prompts (Cmd+Shift+K): 29 built-in AI automation prompts with auto-resolved context variables
• Command palette (Cmd+P): fuzzy search all actions, files (!), file contents (?), terminal buffers (~)
• Configurable keybindings with chord support and conflict detection
• Claude Usage Dashboard: rate limits, 7-day chart, 52-week heatmap, per-project breakdown
• Prompt library (Cmd+K): saved prompts with variable substitution
• IDE launchers: open in VS Code, Cursor, Zed, JetBrains, iTerm2, Tower, or any detected tool — plus user-defined custom launchers with {file}/{repo}/{line}/{column} tokens
• Ideas panel (Cmd+Alt+N): quick notes with image paste and send-to-terminal
• Voice dictation: streaming on-device Whisper with partial results
• Focus mode (Cmd+Alt+Enter): maximize active tab, hide sidebar and panels
• Project Progress: append-only per-project journal of agent done / blocked reports plus captured intent: markers, with a toolbar bell for unseen entries

Developer & automation — CLI, HTTP/MCP control, command blocks, generators, process manager

• tuic CLI: file open with cursor goto, session/agent orchestration, tmux-compat alias mode, auto-update
• HTTP API (REST + WebSocket + SSE): sessions, live output stream, agent spawn, terminal grid/scrollback ops, process stats
• MCP control surface: session / agent / repo / ui / progress tools, drive_agent atomic send→wait→read, delta cursors for incremental reads
• tuic-remote headless daemon (beta): same HTTP/WebSocket API with no Tauri and no GUI, tuic-bridge for the agents on that machine, isolated --instance config + keyring, authenticated on every TCP request
• Custom launchers: user-defined exec + args with {file}/{repo}/{fileDir}/{cwd}/{home}/{line}/{column} placeholder tokens
• Command blocks: terminal output segmented per prompt+output cycle — semantic scrollbar marks, fold (Cmd+Shift+.), block search (Cmd+Shift+B), navigate (Cmd+Shift+Up/Down)
• Generators (command palette): Password, UUID v4/v7, ULID, CUID2, JWT secret, TOTP secret, Nano ID, Slug, Ed25519 keypair — generated natively in Rust
• Process Manager: CPU% and RSS for TUIC and every child process tree, with a self-contained HTML monitor
• Runtime diagnostics: CPU-spike watchdog, FD/thread-leak detection, health snapshots via the local logs endpoint
• Auto-standby: SIGSTOP idle + unfocused PTY groups after N minutes, SIGCONT on focus or agent message

Full feature reference: docs/FEATURES.md

---

Get started

Download the latest release — macOS builds are signed and notarized.

Install via terminal:

# macOS (Homebrew)
brew install sstraus/tap/tuicommander

# macOS / Linux (shell)
curl -fsSL https://tuicommander.com/install.sh | sh

# Windows (PowerShell)
irm https://tuicommander.com/install.ps1 | iex

Want the bleeding edge? The Nightly is rebuilt on every push to main.

Build from source

Prerequisites: Node.js 24+, Rust toolchain, Tauri CLI

pnpm install
pnpm tauri dev      # Development with hot reload
pnpm tauri build    # Production build
pnpm test               # Run tests

See docs/guides/development-setup.md for platform-specific instructions.

Built with

Rust + Tauri v2 backend, SolidJS UI, native terminal via alacritty_terminal + canvas rendering, whisper-rs dictation, Vite + LightningCSS build. ~80 MB RAM.

Documentation

Getting Started	First-run guide
Features	Complete feature reference with all keyboard shortcuts
AI Agents	Agent detection, rate limits, question detection
Project Progress	The per-project journal agents report into
Remote Access	Mobile PWA, SSH tunnels, remote connections, tuic-remote daemon
Plugins	Community plugin registry: browse and install ready-made plugins
Plugin API	Build plugins for TUICommander
HTTP API	REST/WebSocket/SSE endpoints
Architecture	System design and component overview
Development Setup	Build from source
Modes	Desktop, browser, mobile, and remote daemon
Troubleshooting	Common setup and runtime problems

---

Apache 2.0 licensed. Zero telemetry. Runs locally.
Follow the releases — new features land weekly.

License

Apache 2.0 © 2026 Stefano Straus