Agent Deck Review 2026: Terminal Command Center for Claude Code, Codex, Gemini, and OpenCode

Agent Deck is not another coding model, IDE, or hosted app builder. It is a terminal command center for developers who already run CLI coding agents and need a cleaner way to supervise several sessions without losing track of status, branches, prompts, costs, or follow-up work.

That distinction matters for search intent. People searching for "agent deck" are usually not asking for a generic AI coding essay. They want the official GitHub repository, install path, supported agents, pricing reality, and a clear answer to whether a terminal-first control layer is worth adding on top of Claude Code, Codex, Gemini CLI, OpenCode, Aider, or Pi.

Short answer: Agent Deck is worth evaluating if you already use terminal-native coding agents and your problem is coordination, not code generation. It is probably premature if you only run one agent at a time or want a polished beginner IDE.

Quick Verdict

Question	Agent Deck answer
Best for	Developers supervising several CLI coding-agent sessions across real repositories
Not ideal for	Beginners who want one managed editor assistant with minimal terminal setup
Official link	asheshgoplani/agent-deck on GitHub
Pricing	Free MIT-licensed project; upstream agent, model, infrastructure, and notification costs are separate
Latest release checked	v1.9.73, published June 21, 2026
Public signal checked	396 GitHub stars, 49 forks, and fresh June 29, 2026 repo activity when checked on June 30, 2026
Core strength	One TUI and optional web UI for running, grouping, searching, forking, and monitoring agent sessions
Main weakness	Terminal, tmux, git worktrees, and upstream agent setup are still part of the workflow
Closest alternatives	Claude Squad, Orca, Agent of Empires, Paseo, raw tmux plus scripts

What Is Agent Deck?

Agent Deck positions itself as a command center for AI coding agents. The official README describes a TUI where sessions can be running, waiting, or done, with one-keystroke switching between them. The product problem is practical: once several agents are active, raw terminal tabs and shared branches become hard to supervise.

The basic model is:

• install the agent-deck CLI;
• launch or add coding-agent sessions from the TUI;
• keep sessions organized by group and status;
• isolate work with git worktrees when several agents touch the same repository;
• attach MCP servers and skills where needed;
• use conductor workflows and notification bridges for longer-running fleets;
• optionally start the local web UI on http://127.0.0.1:8420.

Agent Deck does not replace Claude Code, OpenAI Codex, Gemini CLI, OpenCode, Aider, or Pi. It sits above those tools and tries to make them easier to operate in parallel.

That is a real category now. The hard part of agentic coding is no longer just "can the model edit files?" The harder operating question is "can a human supervise several autonomous sessions without branch collisions, missed prompts, runaway costs, or unreadable review state?"

Official Links and Installation

Start with the primary source:

• GitHub repository: github.com/asheshgoplani/agent-deck
• Releases: Agent Deck releases
• License: MIT license in the repository
• Tool page: Agent Deck on VibecodingHub

The README lists macOS, Linux, and Windows via WSL as supported host environments. The primary installer is:

curl -fsSL https://raw.githubusercontent.com/asheshgoplani/agent-deck/main/install.sh | bash

Other documented paths include Homebrew, Go install, and building from source:

brew install asheshgoplani/tap/agent-deck
go install github.com/asheshgoplani/agent-deck/cmd/agent-deck@latest
git clone https://github.com/asheshgoplani/agent-deck.git && cd agent-deck && make install

After installation, the normal entry point is:

agent-deck

This setup tells you a lot about who the product is for. If you are comfortable with shell tools, git, tmux, and local agent CLIs, Agent Deck fits the way you already work. If your desired workflow is "open a web app and never think about local environment state," this is the wrong starting point.

Why Developers Are Searching for Agent Deck

Single-agent demos hide the real scaling problem. One terminal session is easy to watch. Five sessions across the same repository are not.

Common failure modes include:

• two agents editing the same branch;
• a waiting session getting buried in another terminal tab;
• one long run losing context while another finishes unnoticed;
• follow-up prompts scattered across tools;
• MCP server setup repeated per session;
• review state split between diffs, terminal panes, and chat transcripts;
• model or token costs becoming hard to attribute.

Agent Deck is interesting because it treats that operator layer as the product. The README documents session groups, search, forking, status detection, cost tracking, MCP management, skills, git worktrees, sandboxing, conductor workflows, Slack or Telegram bridges, and a local web UI. Those are not autocomplete features. They are supervision features.

That also explains why the search query is usually navigational but still deserves a review page. A plain directory entry can give the official link. A good review should answer the next question: should a serious developer add this layer, or keep using raw tmux, Claude Squad, Orca, Agent of Empires, or Paseo?

Core Workflow: TUI, Sessions, Worktrees, and Status

Agent Deck's center of gravity is the terminal UI. The README documents actions for creating sessions, attaching to them, forking them, archiving them, moving them between groups, opening MCP and skills managers, searching, renaming, restarting, and deleting sessions.

The most important feature is not that it can launch another agent. It is that sessions can be organized and observed. Status detection labels sessions as running, waiting, idle, or errored, which is the difference between active supervision and terminal archaeology.

Git worktrees are the other key piece. Agent Deck can create isolated worktrees per task, place them in configured locations, copy selected gitignored files through .worktreeinclude, and run setup scripts after worktree creation. That matters because parallel agent work without branch isolation is how you create review pain for yourself.

If you are already comfortable with git worktree, this should feel natural. If you are not, Agent Deck will not magically remove the learning curve. It packages the pattern, but you still need to understand the consequences of multiple branches, generated files, environment files, and merge paths.

Conductor Workflows and Notifications

Agent Deck's conductor feature is the part that makes it more than a session list. Conductors are persistent agent sessions that monitor and orchestrate other sessions. The README describes a setup flow where a conductor can route updates through Telegram, Slack, Discord-oriented docs, and watcher-style event inputs.

The practical use case is simple: long-running agents should not sit blocked for hours because nobody saw the prompt. A conductor can monitor child sessions, escalate interesting cases, and use status transitions to nudge the human operator.

This is powerful, but it is also where teams should be disciplined. A conductor is another automation surface with permissions, credentials, messaging channels, and policy decisions. Start small. Use it for visibility and escalation before trusting it with broad autonomous control.

MCP, Skills, Forking, Web UI, and Costs

Agent Deck also includes several operator features that matter once agent sessions multiply.

The MCP Manager lets you attach MCP servers per project or globally without editing config files manually. The README also describes MCP socket pooling, which shares MCP processes across sessions through Unix sockets to reduce duplicated background processes.

The Skills Manager is focused on Claude sessions and can attach or detach skills from a managed pool. That makes sense for teams that want reusable agent behavior without copying the same prompt material into every repository by hand.

Session forking is another useful idea. Agent Deck documents fork support for Claude, OpenCode, Pi, and Codex, including worktree-aware defaults. This is valuable when you want to explore two implementation paths without destroying the original session state.

The local web UI is not the main product surface, but it matters for people who want a browser view or read-only monitoring. The README documents agent-deck web and configurable listen addresses and tokens.

Cost tracking is also documented, with automatic collection for Claude Code and parsing support for other tools. Treat that as an operational aid, not a billing source of truth. Your provider dashboards still matter.

Pricing Reality

Agent Deck itself is free and MIT licensed. There is no normal seat-based SaaS pricing page for the core project.

That does not mean the workflow is cost-free. Real usage still depends on the agents and services you connect:

• Claude Code, Codex, Gemini CLI, OpenCode, Aider, Pi, or other upstream tools;
• model subscriptions or API billing;
• MCP servers and any paid APIs they call;
• Slack, Telegram, Discord, tunnel, remote host, or infrastructure choices;
• time spent maintaining local setup, credentials, worktrees, and review process.

This distinction is important. Agent Deck lowers coordination friction, but it does not bundle model access or remove the need to control permissions and spend.

Public Traction and Maturity

Agent Deck is active, but it is still earlier than the largest tools in this category.

When checked on June 30, 2026, the GitHub repository showed 396 stars, 49 forks, MIT licensing, a latest release of v1.9.73 published on June 21, 2026, and fresh repository activity on June 29, 2026. That is enough signal to treat the project as alive and worth evaluating, especially because the README is unusually deep for an operator tool.

It is not enough to pretend Agent Deck has the maturity or adoption footprint of bigger orchestration projects. That is not a dealbreaker. It just means you should evaluate it like an active emerging tool: test it on a non-critical repo, inspect the worktree behavior, check how it interacts with your tmux setup, and keep your upstream agent permissions tight.

Agent Deck vs Claude Squad, Orca, Agent of Empires, and Paseo

Agent Deck vs Claude Squad: Both focus on supervising multiple terminal coding agents with git worktrees. Claude Squad has stronger public adoption signal today and a simpler mental model. Agent Deck is more ambitious around conductor workflows, MCP management, skills, web UI, and notification routing. Choose Claude Squad if you want the established baseline. Test Agent Deck if you want the broader operator surface.

Agent Deck vs Orca: Orca is a desktop worktree IDE for supervising coding agents with a more visual app experience. Agent Deck stays terminal-first and tmux-native. Choose Orca if you want a desktop control plane. Choose Agent Deck if your workflow already lives in terminal sessions and you prefer composable local tools.

Agent Deck vs Agent of Empires: Agent of Empires also combines terminal orchestration, worktrees, and browser access. The difference is less about category and more about implementation taste. Compare the TUI, web dashboard, sandboxing, and conductor models before standardizing.

Agent Deck vs Paseo: Paseo is stronger when cross-device control and self-hosted web/mobile access are central to the workflow. Agent Deck is more attractive when the primary surface should remain a terminal command center with local tmux and agent-session primitives.

Agent Deck vs raw tmux: Raw tmux is enough if you only need panes and windows. Agent Deck adds AI-specific status, session registry, worktree flows, MCP management, forking, conductor workflows, and cost views. The tradeoff is complexity. Do not install a control plane until you actually have a control-plane problem.

Who Should Use Agent Deck?

Use Agent Deck if you:

• already run Claude Code, Codex, Gemini CLI, OpenCode, Aider, Pi, or similar CLI agents;
• frequently supervise more than one agent session;
• want isolated worktrees for parallel tasks;
• need better status visibility than scattered terminal tabs;
• use MCP servers or skills across several agent sessions;
• want Telegram or Slack escalation for long-running work;
• are comfortable reviewing AI-generated diffs before merging anything.

Avoid Agent Deck if you:

• only use one coding agent occasionally;
• want a managed IDE with minimal shell setup;
• dislike tmux, git worktrees, or local environment debugging;
• need mature enterprise controls before adopting a workflow tool;
• expect the orchestrator to make upstream model quality, auth, and permissions disappear.

Bottom Line

Agent Deck is a credible emerging control layer for developers who already use terminal coding agents and need stronger supervision across sessions. Its best ideas are practical: worktree isolation, status awareness, forking, MCP management, conductor workflows, notification bridges, and a local-first terminal surface.

The risk is also clear. Agent Deck can add real value only after your workflow is complex enough to need it. If you are not already running multiple agents, it may become another layer to maintain. If you are running several sessions and losing track of them, it is exactly the kind of tool worth testing.

Start with a small repository, confirm the worktree and tmux behavior, connect only the upstream agents you already trust, and compare it against Claude Squad, Orca, Agent of Empires, and Paseo before making it the center of your agent workflow.