AI Coding Agent Dashboard for Claude Code and Codex
An AI coding agent dashboard becomes necessary the moment one developer stops running one assistant in one visible terminal. Once Claude Code, Codex, OpenCode, Kiro, Gemini, and custom local agents are working in parallel, the team needs a shared answer to a simple operational question: what is happening right now?
The hard part is not drawing a status page. The hard part is making that page useful to the people supervising real work: platform engineers, engineering managers, staff engineers, and security reviewers who need to know which sessions are active, which are blocked, which files changed, which approvals are waiting, what tests failed, and whether a completed task is actually verified.
Why terminal UX turns into an operations problem
A single coding agent can live comfortably inside a terminal or editor. Ten sessions do not. They spread across tabs, tmux panes, worktrees, cloud environments, desktop apps, and logs. A developer may know that something is running, but not whether it is waiting on a permission prompt, burning context, editing the wrong branch, or silently declaring success after a failed test.
That is the visibility gap a dashboard has to close. Not generic usage analytics. Not a monthly chart of seats and tokens. The dashboard needs to behave more like mission control for agent work: live state, ownership, side effects, approvals, cost, and proof.
For teams monitoring Claude Code and Codex sessions, the most useful dashboard answers these questions first:
- Which agents are running, idle, blocked, failed, or awaiting human input?
- Which repository, branch, worktree, or task does each session own?
- Which files did the agent read, edit, create, or delete?
- Which tool calls happened, in what order, and with what result?
- Which approvals are pending, who approved them, and what exact action was approved?
- Which tests, CI jobs, or review checks failed?
- How much token, context, cost, or quota budget remains?
What Claude Code and Codex expose today
Claude Code currently has strong local telemetry primitives for this use case. The brief describes hooks, JSONL transcripts, OpenTelemetry export, and analytics APIs. Its monitoring data can cover token usage, session counts, lines of code, commits, pull requests, cost, tool activity, logs, events, and optional traces.
Hooks are especially important for a live dashboard because they expose lifecycle and tool events. The brief lists events such as PreToolUse, PermissionRequest, PostToolUse, SessionStart, Stop, SubagentStop, and UserPromptSubmit. Hook payloads can include fields such as session_id, transcript_path, cwd, permission_mode, and tool-specific data.
Codex has a different shape. The brief points to CLI sessions, commands such as /status, /permissions, /review, codex resume, codex cloud, and codex mcp, plus sandboxing, approval policy, cloud or self-hosted sessions, and Agents API session webhooks. Those webhooks include lifecycle states such as created, action required, in progress, idle, and failed. The important caveat from the brief: idle means ready for more input, not necessarily successful completion.
That distinction matters. A dashboard that marks idle as done will mislead reviewers. Agent status is not outcome truth.
The minimum dashboard model
A useful dashboard needs a normalized event model because no team should rebuild its view around one provider's log format. Claude Code, Codex, OpenCode, and Kiro expose different hooks, permissions, session IDs, exports, and local files. The dashboard should adapt those inputs into one operational schema.
| Dashboard object | What it should show | Why it matters |
|---|---|---|
| Session | Agent, provider, user, repo, branch, worktree, task, status, started time | Prevents orphaned work and unclear ownership |
| Turn | User prompt, agent response metadata, context size, token usage | Shows why the session changed direction or stalled |
| Tool call | Tool name, arguments or redacted digest, result, duration, error | Turns agent activity into an auditable execution trace |
| File event | Read, edit, create, delete, path, diff summary, owner session | Connects agent work to code review and attribution |
| Approval | Requested action, approver, timestamp, exact approved command or file action | Protects against vague or stale remote approvals |
| Verification | Tests, CI, lint, reviewer verdict, unresolved risk | Separates activity from correctness |
Real-time status is only the first layer
The first win is a live view of sessions grouped by state: working, waiting, blocked, idle, failed, and completed but unverified. This is the problem tools such as ccdeck and Agent HUD point toward in the brief: users lose track of which session needs them, which one is still running, and which one is stuck behind a permission prompt.
But status alone is too shallow. A session can look healthy while working from a bad premise. It can produce a confident final summary after a test failure. The brief uses the community phrase "sanitised optimism" for this failure mode. That phrase belongs on the dashboard as a design warning: do not trust an agent's summary without evidence.
The dashboard should therefore have a verification lane beside every session. It should show the latest test command, exit code, CI result, changed files, review status, and unresolved warnings. If there is no verification, the status should say so clearly.
Hooks, transcripts, and OpenTelemetry each do a different job
The brief makes one pattern clear: a strong dashboard probably needs more than one data source.
Hooks are best for live state. They can surface tool use, permission requests, session starts, stops, and prompt submissions as they happen. That is how a local dashboard can notice a blocked session before the developer remembers to check a terminal tab.
Transcripts are best for history. They preserve the session narrative: what was asked, what the agent tried, what it read, which tools it used, and how it explained itself. They are useful for review, debugging, and reconstructing failures.
OpenTelemetry is best for aggregate observability. It can feed metrics, events, traces, cost views, and enterprise reporting. It is not always the right source for a real-time "needs input now" screen, but it is valuable for adoption, cost, and trend analysis.
The architectural implication is straightforward: collect live events locally, preserve enough transcript history for audit, and export summaries or traces centrally with privacy controls.
Where current tools are converging
The market is early, but the brief shows a clear pattern across community tools.
- Agents Observe validates the hook-to-dashboard architecture with Claude Code hooks feeding a CLI script, API server, SQLite, and a React dashboard.
- agentglass frames the category as cross-provider fleet control, with Claude Code, Codex, Gemini CLI, and OpenCode on one screen.
- ccdeck focuses on live sessions, permission waits, questions, subagents, tool calls, cost, and quota.
- Agent HUD suggests demand for ambient status, notifications, quotas, approvals, and questions outside the browser.
- codelight shows the remote approval and question-answering use case.
- Mission Control-style Claude Code mods move toward execution trace visualization: who acted, which tools ran, and which files changed.
The names differ: dashboard, mission control, HUD, command center, flight deck, observe, glass box. The underlying buyer need is the same. Teams want to supervise multiple semi-autonomous coding sessions without losing auditability, cost control, or developer trust.
Read-only dashboard or control plane?
The biggest product decision is whether the dashboard only observes or also controls. A read-only dashboard is safer and easier to adopt. It can show status, diffs, costs, approvals, and failed checks without becoming part of the permission boundary.
An approval console is more useful, but it raises the stakes. If someone can approve a shell command from a phone, the dashboard must record who approved it, what exact action they approved, which session requested it, and whether the executed action matched the approved action. The brief flags approval laundering and approval-execution binding failures as a live security concern.
A full orchestration plane goes further: it can start, pause, steer, or terminate sessions. That may be valuable for platform teams, but it also turns the dashboard into privileged infrastructure. At that point, access control, audit logging, per-repo policy, and redaction are not optional features.
Performance and privacy are design constraints
Real-time dashboards can damage the workflow they are meant to supervise if they add latency to every hook. The brief cites an Agents Observe launch discussion where blocking hooks cost about 50 to 60 ms per hook before a background shim, then about 3 to 5 ms after the change. That is a useful performance budget: live collection should be lightweight, asynchronous where possible, and measured under real agent load.
Privacy has the same practical weight. Raw prompts, code snippets, command output, tool arguments, environment paths, secrets, and transcripts may contain sensitive data. A platform-grade dashboard should default to metadata and summaries, then allow limited raw capture for debugging or incidents with access controls and retention rules.
Local-first collection with centralized summaries is the likely team compromise. Developers keep code and raw transcripts close to the machine. Leaders still get cross-repo health, cost, and governance signals.
A reference architecture for teams
For a team running Claude Code and Codex side by side, a practical dashboard architecture looks like this:
- Agent adapters: One adapter per provider or harness. Claude Code can use hooks, transcripts, and OpenTelemetry. Codex can use CLI or cloud session state, permissions, sandbox metadata, and session webhooks where available.
- Local collector: A small process receives events, redacts sensitive fields, writes durable local state, and avoids blocking the agent loop.
- Session registry: Every session gets stable links to user, repo, branch, worktree, task, base commit, and current status.
- Normalized event schema: Tool calls, approvals, file events, token or cost data, and verification results use common names across agents.
- Verification lane: Test output, CI status, lint results, review verdicts, and unresolved risks sit beside the agent's self-reported status.
- Approval audit log: Every human approval records the exact action, actor, time, session, and outcome.
- Team dashboard: Central views show health, blocked sessions, cost, quota, failed checks, and policy exceptions without exposing raw content by default.
Buying or building checklist
Use this checklist before adopting or building an AI coding agent dashboard:
- Does it show live blocked sessions, permission prompts, questions, idle sessions, and failures?
- Can it distinguish idle, done, failed, awaiting human, and completed but unverified?
- Does it map every session to repo, branch, worktree, task, user, and provider?
- Can it show file diffs and attribution when multiple agents work in the same repository?
- Does it capture tool calls in order, including errors and retries?
- Does it surface tests, CI, lint, review state, and failed verification?
- Does it track token, context, cost, and quota signals by session and team?
- Does it support Claude Code hooks, transcripts, and telemetry without adding noticeable latency?
- Does it support Codex session state, permissions, sandbox metadata, and webhooks where relevant?
- Does it redact raw prompts, code, command output, secrets, and transcripts by default?
- If it supports remote approvals, does it bind the approval to the exact executed action?
- Can it export aggregate data for leadership without turning into invasive developer surveillance?
Related reading: AI agent observability for coding agents, coding agent cost monitoring, Claude Code hooks for permissions, and multi-agent coding orchestration.