# cc-agent-tree: Live Terminal Dashboard for Claude Code Agents

> Source: <https://byteiota.com/cc-agent-tree-claude-code-terminal-monitor/>
> Published: 2026-10-31 10:13:08+00:00

Claude Code’s multi-agent mode is powerful and opaque in equal measure. You launch an orchestrator, it spawns subagents, and you stare at scrolling terminal output with no clear picture of which agent is burning your budget, which one stalled, or which one quietly looped itself into a multi-billion-token bill. This week, four developers independently shipped the same answer: an open-source terminal dashboard that reads the transcripts Claude already writes and draws a live tree of everything running.

## The Cost of Flying Blind

Claude Code has a native `/agents` view. It shows a flat list of running agents. That is the entire observability story Anthropic ships today. No tree structure, no per-agent cost breakdown, no timeline, no way to switch a stalled subagent’s model without stopping everything.

The community has been vocal about this. At least six GitHub issues filed against the anthropics/claude-code repository between May and June 2026 describe the same structural gap: the subagent surface lacks the observability and control primitives the main agent surface has. One developer [reported that 98% of a 2.4-billion-token multi-agent run was re-sent context](https://github.com/anthropics/claude-code/issues/106025) because a subagent looped undetected. No alert. No dashboard. Just a bill.

Blind multi-agent runs are not just inconvenient — they are a budget risk that scales with task complexity. As agents get longer-running tasks, the gap between what you can see and what is actually happening becomes expensive.

## What cc-agent-tree Does

The core insight behind all four tools is the same: Claude Code already writes detailed JSONL transcripts. Every session gets a file at `~/.claude/projects/<project>/<session>.jsonl`. Every subagent gets its own file at `<session>/subagents/agent-<id>.jsonl` with a `.meta.json` beside it. These files exist regardless of what third-party tooling you install. The agent-tree tools tail them, parse them, and draw a live terminal UI. No daemon. No hooks. No additional Claude configuration. Nothing touches your running session.

That read-only, zero-footprint approach is the right architectural call. Observability tooling that can interfere with the thing it observes is a liability. These tools watch; they do not touch.

## Four Tools, Four Use Cases

Four separate implementations shipped within days of each other. They share the JSONL-reading approach but diverge meaningfully in what they do with it.

**[niemes/cc-agent-tree](https://github.com/niemes/cc-agent-tree)** is the closest to a pure monitor. Python 3.10+, no dependencies beyond a true-colour terminal and a monospace font at minimum 84×40 cells. Run `python3 agent_tree.py`, pick a session, and get a live TUI showing the main session, most-used tools, and a card per open subagent. An optional bundled plugin writes richer event data to `~/.local/state/agent-tree/events/` for deeper subagent detail. The `--demo` flag lets you try it without a live session:

```
git clone https://github.com/niemes/cc-agent-tree
cd cc-agent-tree
python3 agent_tree.py --demo
```

**[MikeGT4/agent-tree](https://github.com/MikeGT4/agent-tree)** is the interactive version. Installed as a Claude Code plugin and opened with `/agent-tree`, it draws a side pane with agents as a tree of boxes: main session, subagents, cost. Clicking an agent shows its task, tool calls, and latest answer. Clicking the model lets you switch to a different model mid-session. You can also set effort level — Low, Medium, High, XHigh, or Max — and stop a specific agent without killing the whole session. Each box carries a timeline bar; the main box shows total session cost.

**[SeanoChang/agent-tree](https://github.com/SeanoChang/agent-tree)** focuses on post-run analysis. Three views: Tree (nested agents with status and token counts), Timeline (one horizontal bar per agent), and Trace (every tool call, edit, and hand-back in chronological order per agent lane). It stores the last 150 runs across sessions per repository. Install with `/plugin install agent-tree --marketplace SeanoChang/agent-tree`.

**[lifrary/agent-tree](https://github.com/lifrary/agent-tree)** takes a different angle: session navigation and resumption. It renders any Claude Code session as a numbered file-tree in the terminal, organized into phases (user prompts) and sub-actions (file edits, tool calls). Pick a numbered node and get resume markdown you can paste into a new session to continue or fork from that exact point. Available as both a CLI tool and MCP plugin.

## Four Tools in One Week Is a Signal

When four developers independently ship variations of the same tool in a single week, that is not coincidence — it is a demand signal. The pattern is familiar: [lazygit](https://github.com/jesseduffield/lazygit) emerged when terminal Git users found existing GUIs inadequate. [k9s](https://github.com/derailed/k9s) appeared when `kubectl` alone stopped being sufficient for running Kubernetes in production. Simultaneous invention confirms the native tooling has left a real gap.

Anthropic is aware. [GitHub issue #24537](https://github.com/anthropics/claude-code/issues/24537) asks for a native Agent Hierarchy Dashboard with a unified real-time visualization for multi-agent workflows. That issue is open. The community tools are shipping now.

## Which One to Use

- **niemes/cc-agent-tree** — zero installation overhead, just need to see what is running
- **MikeGT4/agent-tree** — interactive control, model switching, per-agent stopping, cost tracking
- **SeanoChang/agent-tree** — post-run analysis with timeline and trace history
- **lifrary/agent-tree** — long sessions that break and need clean resumption points

The common thread: your agents are already writing the data. You just needed a tool that would read it back to you.