Claude Agent Dashboard / v1.0.0 / MIT / Zero dependencies github ↗
Claude Code plugin

Every agent you have running, on one screen.

A local command center for Claude Code. Spawn, watch, and talk to many sessions at once — as live tiles at localhost:4747.

/plugin marketplace add Abhay-Sastha-S/claude-agent-dashboard
then /plugin install agent-dashboard → /dashboard
localhost:4747 3 active · $4.12 today
Active elsewhere — 2 sessions in other terminals
Illustration of the interface — not a live connection
Why it exists

One session per terminal tab stops working the moment you're doing more than one thing.

You can't see stateA tab is either the foreground one or a rectangle you forgot about. Which agent is working, which finished, which is stuck waiting on you? You find out by cycling through tabs.
Long tasks go darkA repo-wide refactor runs for many minutes. The only honest status is buried in scrollback, so you either babysit one agent or lose track of all of them.
Cost is unattributedYou learn what a session cost when it ends, one session at a time, somewhere you have to go look.
Sessions started elsewhere are orphanedA session you began in an IDE is a transcript on disk and nothing more. Close the window and you need its ID to get back to it.
Parallelism is the normal case nowSubagents, worktrees, and multiple repos mean several agents are genuinely in flight at once. The interface never caught up with the workload.

Subagents solve fan-out inside one task. This solves the layer above: many independent, long-lived, human-steerable sessions, all visible at once. An air traffic control view, not another chat window.

Design principles

A view onto your sessions — not a copy of them.

Not a wrapper

It shells out to the real CLI

Every session is a genuine claude process in stream-json mode. Your settings, MCP servers, hooks, and skills apply unchanged. Nothing to keep in sync with upstream.

Same session

Resuming never forks

Restart and adopt both use --resume without --fork-session, so the session ID survives and the transcript in ~/.claude/projects stays the single source of truth.

Local and boring

One server file, one page

No node_modules, no build step, no telemetry, no account. Binds to 127.0.0.1 and makes no network calls of its own.

Disposable

It survives itself

Kill the server and every session is still on disk and still resumable. The dashboard is throwaway; your work isn't.

What it does

Spawn, steer, and track — plus a live view of sessions you started somewhere else.

Tile grid

Every open session is a tile with its own chat and composer. Drag headers to reorder, maximize one, close a tile without stopping its session, rename and tag.

Spawn agents

Name, tags, working directory with autocomplete, model, permission mode, and an optional first instruction so it starts working immediately.

Chat in place

Full multi-turn chat per tile with token-level streaming and file attachments. Sending to an exited session auto-resumes it.

Track everything

Sidebar grouped by Working / Awaiting input / Error / Exited, with live indicators, last-message previews, per-session cost, and total spend.

Control

Interrupt a turn mid-flight, restart an exited session, or switch model or permission mode without losing the conversation.

Adopt outside sessions

Sessions running in other terminals and IDEs are listed live and readable. Idle ones can be adopted and continued here — adopting a running one is blocked, because it would fork.

Use cases

It earns its keep at two or more concurrent sessions.

SituationWhat the dashboard gives you
Parallel feature workThree branches or worktrees, one agent each — three tiles on one screen. No tab archaeology.
Long migrationsStart the codemod, glance at the status dot, go do something else. Interrupt from the tile the moment it goes wrong.
Fan-out then triageSeveral agents chasing different hypotheses; read their conclusions side by side instead of serially.
Multi-repo changesOne session per repo, each already in the right directory, all steerable from one place.
Reviewing agent workPer-session transcript, turn count, and cost, without reconstructing scrollback.
Picking up yesterdaySessions from the last 48h listed with their opening prompt as the title — adopt and continue instead of hunting for an ID.
Budget awarenessLive total spend across every agent, on the same screen as the work.
ScriptingThe whole thing is a plain JSON and SSE API — drive it from CI, a cron job, or your own UI.

When not to use it: if your work is one task at a time in one repo, plain claude in a terminal is better.

How it works

One long-lived process per session, streamed to the browser.

browser (index.html)
   │  fetch + SSE
   ▼
server.js  ── spawn ──►  claude -p --input-format stream-json
   │                     --output-format stream-json --include-partial-messages
   │                         │  stdout: JSON lines
   │  ◄──────────────────────┘
   ├─ ~/.claude-dashboard/   sessions.json, events/<id>.jsonl, uploads/
   └─ ~/.claude/projects/    read-only: discover + tail outside sessions
  • A message is a JSON line written to the child process's stdin; the process stays alive across turns.
  • Every stdout event is appended to a per-session JSONL log and fanned out over SSE. Partial-message deltas stream live but are never persisted — the final events carry the same content.
  • Interrupts are control_request messages on stdin, not signals, so the agent stops cleanly mid-turn.
  • Outside sessions are discovered by reading ~/.claude/projects transcripts — head for the working directory and opening prompt, tail for the latest text — behind an mtime-keyed cache.
  • History prefers the canonical Claude transcript when one exists, so turns you drove from an IDE show up here too.
Permission modes

A headless agent can't stop and ask you — so you choose the posture up front.

ModeBehaviour
acceptEditsDefault. Auto-accepts file edits; other tools follow your settings allowlist.
dontAskNever prompts; denies anything not pre-allowed.
planRead-only planning mode — the safest choice for exploration.
autoClaude Code's auto classifier decides.

Pick the narrowest mode that still lets the task finish, and use plan for anything you haven't scoped yet. Modes are switchable from the tile without losing the conversation.

Install

Two commands, or clone and run Node.

As a plugin
/plugin marketplace add Abhay-Sastha-S/claude-agent-dashboard
/plugin install agent-dashboard
/dashboard              # start it, or report that it's already up
/dashboard restart      # warns first if agents are mid-task
/dashboard stop
Manually
git clone https://github.com/Abhay-Sastha-S/claude-agent-dashboard.git
node claude-agent-dashboard/server.js     # → http://localhost:4747
DASH_PORT=5000 node server.js             # different port

Requires Node 18+, the claude CLI on your PATH, and an authenticated Claude Code install. macOS and Linux; Windows is untested.

Before you run it

It's a single-user local tool, and it trusts whoever reaches the port.

No authentication, by design

The server binds to 127.0.0.1 only. Don't port-forward it, tunnel it, or bind it to 0.0.0.0 — anyone who reaches the port can spawn agents with your credentials.

  • It reads ~/.claude/projects to find your sessions. Those are your transcripts, and everything stays on your machine.
  • Agents spawned here run in the permission mode you chose and cannot ask for confirmation. Treat dontAsk and acceptEdits with the care you'd apply in a terminal.
  • Restarting the server closes stdin on every child process, so tiles show "exited" — sending a message resumes them with the same session ID.
  • Sending to a session that is also open in another terminal at the same time isn't safe; the tile warns you when it detects this.
Credits

What this is built on, and whose idea it was.

  • The idea — the tile-grid command center is modelled on Devin Desktop's Agent Command Center. This is an independent implementation of that idea for Claude Code, not affiliated with or endorsed by Cognition.
  • Claude Code — by Anthropic. Every session here is a real claude process; the dashboard depends on its stream-json input/output format, its control_request interrupt protocol, and the transcript layout under ~/.claude/projects. Claude and Claude Code are Anthropic trademarks. This project is unofficial and not affiliated with, endorsed by, or supported by Anthropic.
  • No runtime dependencies — the server uses only the Node standard library, and the page ships no third-party CSS or JS. Nothing else is bundled or vendored.
  • Build and release — CI runs on GitHub Actions with actions/checkout and actions/setup-node, and validates manifests with the claude CLI.
  • Written with Claude Code, which is co-author on the commits that built it.