Agent Deck
GitHub

Open source · MIT

Stop watching one agent.
Run the whole team.

Runs your AI coding agents under one background daemon, shows what each of them is doing in real time — in a terminal UI or in a desktop app, both watching the same agents — and starts new work for you: a team under one orchestrator, an isolated unit in its own copy of the repo, or a task that fires on a schedule.

Hand it to your coding agent

Paste this into the coding agent you already use. It installs the deck, sets it up, and tells you what it can do and how to use it, so you can pick where to go from there.

Read https://agent-deck.devopstoolkit.ai/llms.txt, then install dot-agent-deck, set it up for me, and explain what it does and how to use it.

Prefer to do it yourself? Installation guide →

Agent Deck’s terminal UI on the dot-agent-deck-dispatch-issue-544 orchestration tab — six role cards down the left, orchestrator, coder, reviewer, auditor, tester and release, run by Claude Code, Pi, OpenCode and Codex, with tester Working and the rest Idle, beside the orchestrator’s pane showing its report on the pull request it prepared, over a footer reading 15 active, 4 working, 1 thinking, 10 idle
The desktop app’s Agent dashboard across all daemons — 43 agents over 3 daemons — with a remote daemon’s standalone agents above two six-role orchestrations: the first lists 01 orchestrator, marked ORCHESTRATOR, then coder, reviewer, auditor, tester and release, one running and five waiting, each with its uptime

The same six-role orchestration in both clients. In the terminal UI its roles are cards beside the orchestrator’s pane, Claude Code, Pi, OpenCode and Codex side by side; in the desktop app they are a group on a dashboard that spans every daemon, with the orchestrator marked.

Drives the client you already use

Any other command still runs in a pane — it just gets no live status tracking. Adapters for Gemini CLI and Aider are designed and open, not shipped.

Two clients, one daemon

The agents run under a small background daemon, not inside a window. The terminal UI and the desktop app are two ways of looking at it, so an agent you start in one shows up in the other, and closing either leaves the agents running.

The terminal UI with four agent cards on the left, each showing its status, directory and last prompt, and the focused agent’s terminal pane on the right

Terminal UI

The dot-agent-deck binary, in the terminal you already use: agent cards beside their live panes, keyboard first, with the Schedules manager and remote hosts over ssh. It attaches to one daemon at a time.

The desktop app’s dashboard with four agents in one daemon section, each row showing its status, name and uptime

Desktop app (alpha)

A native window for macOS on Apple Silicon and Linux amd64: one dashboard over several daemons at once — this machine and remote ones — with each agent’s terminal a click away, and voice control. It connects to a running daemon and starts none of its own.

Read about the desktop app →

Why Agent Deck

Running one AI agent at a time, you're still a software engineer who happens to use AI. Running many at the same time, you stop being one. You become a project manager supervising a team, a tech lead unblocking them, an architect designing the approach, a product manager deciding what to build.

The agents do the work — writing the code, running the tests, watching the pipelines, answering the review comments. Your job is everything around it — defining the work up front, supervising it in flight, and validating that the right thing got built. None of this is new. It's the same craft people have practiced for decades. The team just looks different.

Agent Deck is the tool that lets you do that without losing your mind. One place holds all of it — a lone agent, a team working under an orchestrator, a unit off in its own copy of the repo — and every one of them is something you can open, watch and type into, in the terminal you already use or in a desktop window beside it, with the agent client you already know.

How it works

01

Start an agent

Pick a directory and choose what starts there: Ctrl+n in the terminal UI, New agent in the desktop app. A single agent on the command you give it. A full multi-agent orchestration, every role at once. A dispatcher you can ask for isolated work. Or a scheduled task, written here and fired later by the deck itself.

Terminal UI The New Agent form — Dir /tmp/storefront, a Mode row offering No mode, Orch: review-team, schedule and dispatcher, Agent on auto, Name storefront, Command claude, and Submit and Cancel buttons
The form Ctrl+n opens once the directory is picked. The Mode row is where the choice above is made — a plain agent, a scheduled task, a dispatcher, and review-team, which is not a built-in option but the orchestration this directory defines.
Desktop app The desktop app’s New agent dialog over the Agent dashboard — daemon Local daemon, directory /home/dev/demo-project, a Mode row offering No mode, Orch: demo-loop, schedule and dispatcher, Name demo-project, an empty Command field, and Discard and Create agent buttons
The desktop app’s New agent dialog makes the same choice, after asking which daemon to start the agent on. demo-loop is not built in: it is the orchestration this directory defines.
02

Watch every one of them

Every agent shows up live, with what it is doing right now, the tool it is running, its directory and its last prompt, and nothing for you to wire up. In the terminal UI each one gets a card, and the cards get tighter the more agents you run, because the deck would rather shrink them than make you go looking for one. In the desktop app each one gets a row with the columns you choose, and one dashboard can hold the agents of several daemons, on this machine and on remote ones.

Terminal UI A deck with the Dashboard and four orchestration tabs along the top and six agent cards down the sidebar — ClaudeCode, Pi, OpenCode and Codex filling the orchestrator, coder, reviewer, auditor, tester and release roles, two marked Working and the rest Idle — the cards all laid out the same way, with the directory, the last prompt, the command last run, the time since the last activity and a tool count, over a footer reading 23 active, 2 working, 1 thinking, 20 idle
Four different agent clients — Claude Code, Pi, OpenCode and Codex — running side by side under one orchestrator, and the deck reads all of them the same way: the same card, the same live status, whichever client is behind it. The header counts the six sessions in view out of the deck’s 25; the footer counts every agent it is holding: 23 active, 2 working, 1 thinking, 20 idle.
Desktop app The desktop app’s Agent dashboard showing All daemons: a Local daemon section with four standalone agents and a dev@build-box section with two, each row showing its status, running or waiting, its name and its uptime, under counters reading 6 agents, 3 running, 3 waiting and daemons 2/2
Two daemons on one dashboard, this machine and a remote build box, each in its own section with its own New agent button.
03

Let one agent run the others

Define the roles your project needs — orchestrator, coder, reviewer, release — and one agent hands each piece of work to the right one. Every worker starts fresh, with only the context it was given, and you watch the hand-offs land: across the orchestration’s tab in the terminal UI, down its group in the desktop app. If a worker goes quiet, the deck tells the orchestrator, so a stalled run does not sit there unnoticed.

Terminal UI Orchestrator delegating to reviewer and auditor in parallel — both cards light up simultaneously
One agent delegating to two others at once. Both cards light up together.
Desktop app The desktop app’s Agent dashboard with a demo-loop orchestration group below the standalone agents: 01 planner, marked ORCHESTRATOR, and 02 builder, both running, with a Close button on the group’s header
In the desktop app an orchestration is a group: its roles in order, the one you message marked ORCHESTRATOR, and one Close for all of them.
04

Send work off on its own

Ask a dispatcher for something — “work on the search bug” — and it makes a separate copy of your repository and puts an agent, or a whole orchestration, to work inside it. It works in that copy rather than in your working tree, so start as many as you like and carry on with what you were doing. Each unit arrives on the deck, as a card or a tab in the terminal UI and as a row or a group in the desktop app, and reports back when it is done.

Terminal UI A dispatcher pane in the terminal UI. The request asks for three dispatched agents or teams at a time, counting the two already running, and a stop at twenty in total; the dispatcher reads it back as a standing loop that keeps three units running, dispatches a fresh one each time a slot frees, and stops once twenty have been dispatched, with eighteen more to go
A dispatcher pane with two units already up, asked to keep three running at a time and stop at twenty — which it reads back as a standing loop with eighteen still to go. In the desktop app a dispatcher is an agent like any other: you talk to it in its pane, and the units it starts appear on the dashboard.

Who this is for

  • You already run more than one coding agent at a time, and you are losing track of what each one is doing.
  • You would rather keep your own tools than move into someone else’s IDE to get a dashboard: the terminal you have spent years configuring, or a plain desktop window beside it.
  • You want one agent to plan the work and hand pieces of it to others, with somewhere to watch that happen.

If you run one agent, in one window, and that is working fine — this is not for you yet. Come back when the second one starts drifting.

Four decisions that shaped it

01

Your terminal, or a window

The terminal UI runs in Ghostty, iTerm2, Alacritty, Kitty, WezTerm — whatever you already configured — as a guest, not a replacement, with no multiplexer to set up underneath. The desktop app is a native window over the same agents, so you can use either, or both at once.

02

Uses your agent client

Claude Code, OpenCode, Pi, Codex or Devin — keep the shortcuts, skills, and configs you already dialed in. No new agent client to learn.

03

Closing the window does not stop the work

Detach the terminal UI or quit the desktop app, and the agents carry on without you; open either again and you rejoin the same agents, mid-run. The same holds over ssh — agents running on another machine stay running when you disconnect.

04

Keyboard, pointer or voice

In the terminal UI every action is one or two keystrokes away, because managing a team of agents has to fit in muscle memory, and a button bar along the bottom names each command and the key it answers to. The desktop app is built for the pointer, with a few keys of its own, and it can be driven by voice: open screens, start a new agent, and type into one.

Runs where you work

  • macOSIntel & Apple SiliconSupported
  • Linuxamd64 & arm64Supported
  • Windowsthrough WSL, as Linux; no native Windows build yetVia WSL
  • Desktop appmacOS on Apple Silicon and Linux amd64Alpha

Prefer to do it yourself? Installation guide →

One prompt to set it up. One place for everything you have running.

Hand it to your agent Browse the source

For agents: every docs page, as Markdown

The docs are Markdown, written for the coding agent that sets the deck up for you. An AI agent should start at /llms.txt: it indexes every page below, and /llms-full.txt holds all of them in one file. Once the deck is installed, dot-agent-deck docs prints the same pages as they are for that version, with no network access.

  • Getting StartedInstall the binary, launch the deck, start one agent and check each step, then find the next feature to set up.
  • InstallationInstall, verify, upgrade and uninstall the dot-agent-deck binary (Homebrew, release download, Nix or source), its agent hooks, and the desktop app; inspect and stop the local daemon.
  • Session ManagementWhat each agent status and card marker means in both clients, and how to detach from, resume or clear your workspace.
  • OrchestrationSet up a multi-role orchestration in .dot-agent-deck.toml, start it in either client, and the full role, delegate and work-done reference.
  • Idle Workers & NotificationsWhat the deck reports to an orchestrator about a stuck, waiting, blocked or exited worker, and how to tune or turn the reports off.
  • Dispatcher ModeStart background work units (one agent or a team) from a dispatcher pane, check they started, and clean up afterwards.
  • SchedulesRun a prompt on a cron schedule, or dispatch agents onto open GitHub issues: set up, check, troubleshoot, plus the full schedules.toml, cron and schedule CLI reference.
  • ConfigurationEvery configuration file and environment variable: config.toml (default_command, default_dir, bell), the project .dot-agent-deck.toml, the experimental flag, and the desktop app's desktop.toml.
  • Remote EnvironmentsRun the deck and its agents on a remote host over ssh: connecting, detaching, reattaching, version skew and failure modes.
  • Remote Environment RequirementsWhat a Linux or macOS host must provide before dot-agent-deck remote add can register it as a remote.
  • Remote RecipesBootstrap commands for a Linux or macOS host, the reverse-tunnel recipes, and reading remote doctor's output.
  • Keyboard ShortcutsEvery TUI keyboard shortcut and mouse action, and how to customize them in keybindings.toml.
  • Desktop AppWhat the desktop app (alpha) is, what it needs to run, and what it has and lacks compared with the TUI.
  • DashboardThe desktop app's main screen: agents per daemon, their statuses, the agent pane, and closing agents and orchestrations.
  • New AgentStart an agent from the desktop app: choose the daemon, the directory, the mode and the command.
  • DaemonsWatch local and remote (ssh) daemons from the desktop app: add, test, choose and remove them; the list is shared with the CLI's remotes.toml.
  • SettingsThe desktop app's settings and desktop.toml: appearance, zoom, the settings file's keys, and the app's keyboard shortcuts.
  • Voice ControlTurn on and use voice control in the desktop app: dictating to an agent in typing mode, choosing between matches, the speech and command services it needs, their settings, and what is sent where.
  • TroubleshootingSymptoms, causes and fixes for common problems with logs, hooks, spawning agents, upgrades, delegation, panes, configuration, schedules, remotes and the desktop app.
  • LicenseThe license dot-agent-deck is distributed under (MIT).