Coding agent dashboard: Claude Code, Codex and OpenCode in one view

Updated 24 October 2026

Once you run three or four coding agents at a time, the terminal tabs stop telling you anything useful. You want one place that shows every session, which ones are waiting on you, and ideally a way to answer them without hunting for the right window. This guide compares the real options for a coding agent dashboard today: Claude Code’s built-in agent view, tmux, Herdr, OC-Claw, Agent Pets, and a small dashboard you build yourself from hooks.

The short answer

1. What a coding agent dashboard needs to do

Most “dashboards” do one or two of these well. Before you pick, decide which ones you care about:

• State for every session. Working, waiting on you, or done, with the project name, so you know which row is which without opening it.
• Who’s waiting, at the top. A blocked agent costs you time every minute nobody notices it. Waiting sessions should stand out, and ideally reach you when you’re in another app.
• Answering from the dashboard. Seeing that an agent wants to run npm install is half the job. Approving it, or sending the next message, without switching windows is the other half.
• Every agent you use. If you run Claude Code and Codex side by side, a Claude-only view leaves half your sessions out.
• Every session, however you started it. Some tools only see sessions they launched; others see anything with hooks installed.

2. The Claude Code agent dashboard: agent view

Claude Code ships its own dashboard, in research preview. Run:

Terminalclaude agents

Every prompt you type there starts a new background session. Each session is a row grouped under Needs input, Working and Completed, with a short summary of what it’s doing or asking. Press Space to peek at a session and reply, or Enter to attach to the full conversation. To bring a session you already have open into the list, run /bg in it or press ← on an empty prompt. Background sessions keep running after you close agent view.

What to know before you rely on it:

• It shows Claude Code only, and only background sessions. Sessions open in other terminal windows appear after you background them.
• A reply from the peek panel doesn’t answer a permission prompt. It waits in the queue until you attach with → and answer the prompt there.
• It notifies you when a background session needs input or finishes only while agent view is open.
• For scripts, claude agents --json prints active sessions, interactive and background, as JSON, including a status of waiting and what the session is waiting for. That makes it a good data source if you build your own view.

For more on agent view next to Agent Pets, see Agent Pets vs Claude Code agent view.

3. tmux: one window per agent, with bell flags

If your agents already live in tmux, you have a basic dashboard for free. Give each session its own window named after the project. tmux’s monitor-bell option is on by default: when a program in a background window rings the bell, tmux adds ! to that window in the status line, and prefix then Alt+N jumps to the next window with an alert.

The agents just need to ring the bell. In Claude Code, set "preferredNotifChannel": "terminal_bell" in ~/.claude/settings.json; in Codex, set notification_method = "bel" in the [tui] section of config.toml. Claude Code only rings for a permission prompt after you’ve been idle for about six seconds, so a hook that flags the window right away works better. Using Claude Code in tmux has both setups.

The limits: the flag tells you which window, not what it wants, it clears as soon as you look at the window, and you still answer in the terminal.

4. Herdr: a terminal multiplexer built for agents

Herdr is a free, open-source “agent multiplexer”: think tmux for coding agents, with workspaces, tabs and panes. It runs as a background server, so agents keep working when you close the laptop, and it can add other machines over SSH.

For each agent it recognizes, Herdr reads the live bottom of the pane and marks it idle, working or blocked, then rolls that state up to the tab and workspace in its sidebar, so a blocked agent makes its whole workspace look blocked. It notifies you when an agent finishes or needs you and lets you jump straight to that pane. Its docs list Claude Code, Codex, OpenCode and omp among the agents it supports, along with Cursor, Copilot CLI, Gemini CLI and many more.

You approve and reply in the agent’s pane, as you would in any terminal. Pick Herdr if you want the terminal to be the dashboard and you run many agents or work on remote machines. More detail: Agent Pets vs Herdr.

5. OC-Claw: a desktop pet in the notch

OC-Claw is a free, open-source desktop pet for macOS and Windows. A character in the macOS notch (or near the Windows taskbar) animates while your agents work and sleeps when they’re idle. Hover over the notch to open a panel with sessions, live conversations and, for some agents, token stats. It listens to Claude Code, Codex, Cursor and Gemini CLI through hooks, and also covers OpenCode, Hermes and OpenClaw.

Because it sits in the notch, you see it whatever app is in front. Its site shows an Approve control; we haven’t tested it. Pick OC-Claw if you want something free that covers agents beyond Claude Code, Codex and OpenCode. More detail: Agent Pets vs OC-Claw.

6. Agent Pets: every session on every browser page

If you spend the waiting time in the browser, Agent Pets puts the dashboard where you already are. It’s a Chrome extension with a small local helper:

• Every live Claude Code, Codex, OpenCode and omp session gets its own named pet that walks along the bottom of every page in Chrome, Arc, Brave or Edge, including sessions in ordinary terminal windows, not only background ones.
• A capsule above each pet shows its state: Thinking, Your Turn, Allow Bash? or Done. The toolbar badge counts the sessions waiting on you.
• When an agent asks to run a command or edit a file, its pet bounces. Click it, see the request, and answer Allow, Always or Deny from the page you’re on (Codex gets Allow and Deny; omp approvals stay in the terminal).
• Read any session’s latest answer and send its next message without leaving the tab. A busy Codex takes your message next through codex queue.
• In another app, a desktop notification names the pet that needs you, with Allow and Deny on it.

Setup is npx getagentpets init, which connects the agents and installs the helper, then you load the extension in Chrome. Everything runs on your computer: no account, no cloud, and your code and prompts never leave your machine. The terminal prompt keeps working, so you can answer in either place.

Get Agent Pets — was $25, now $6$25 $6Get Agent Pets — $25

7. Build your own: hooks that write a status file

Claude Code and Codex both run hooks at the moments a dashboard cares about, and both pass the hook a JSON object with session_id, cwd and hook_event_name. A short script can turn those events into one small file per session. Save this as ~/.agent-status/hook.py:

~/.agent-status/hook.py#!/usr/bin/env python3
import json
import os
import sys
import time

agent = sys.argv[1] if len(sys.argv) > 1 else "agent"
event = json.load(sys.stdin)
states = {
    "SessionStart": "idle",
    "UserPromptSubmit": "working",
    "PostToolUse": "working",
    "PermissionRequest": "waiting",
    "Stop": "done",
    "Interrupt": "idle",
}
folder = os.path.expanduser("~/.agent-status")
os.makedirs(folder, exist_ok=True)
path = os.path.join(folder, f"{agent}-{event.get('session_id', 'unknown')}.json")
name = event.get("hook_event_name", "")

if name == "SessionEnd":
    if os.path.exists(path):
        os.remove(path)
elif name in states:
    status = {
        "agent": agent,
        "project": os.path.basename(event.get("cwd", "")),
        "state": states[name],
        "since": int(time.time()),
    }
    with open(path + ".tmp", "w") as f:
        json.dump(status, f)
    os.replace(path + ".tmp", path)

It prints nothing, so it never changes what the agent does: the permission prompt still appears as usual. Point Claude Code’s events at it in ~/.claude/settings.json:

~/.claude/settings.json{
  "hooks": {
    "SessionStart": [{ "hooks": [{ "type": "command", "command": "python3 ~/.agent-status/hook.py claude" }] }],
    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "python3 ~/.agent-status/hook.py claude" }] }],
    "PermissionRequest": [{ "hooks": [{ "type": "command", "command": "python3 ~/.agent-status/hook.py claude" }] }],
    "PostToolUse": [{ "hooks": [{ "type": "command", "command": "python3 ~/.agent-status/hook.py claude" }] }],
    "Stop": [{ "hooks": [{ "type": "command", "command": "python3 ~/.agent-status/hook.py claude" }] }],
    "SessionEnd": [{ "hooks": [{ "type": "command", "command": "python3 ~/.agent-status/hook.py claude" }] }]
  }
}

If the file already has a "hooks" key, add these events inside it rather than adding a second one. Codex reads the same shape from ~/.codex/hooks.json: copy the block, change claude to codex, add an Interrupt entry, then open Codex and trust the new hooks with /hooks. OpenCode has no hooks file; a plugin can write the same files from its events.

Now the viewer. Save this as ~/.agent-status/show.py:

~/.agent-status/show.py#!/usr/bin/env python3
import glob
import json
import os
import sys
import time

rows = []
for path in glob.glob(os.path.expanduser("~/.agent-status/*.json")):
    with open(path) as f:
        rows.append(json.load(f))

waiting = [r for r in rows if r["state"] == "waiting"]
if "--count" in sys.argv:
    print(f"{len(waiting)} waiting" if waiting else "")
    sys.exit()

order = {"waiting": 0, "working": 1, "done": 2, "idle": 3}
for r in sorted(rows, key=lambda r: order.get(r["state"], 9)):
    minutes = (int(time.time()) - r["since"]) // 60
    print(f"{r['state']:<8} {r['agent']:<9} {r['project']:<24} {minutes}m")

Keep it running in a spare terminal pane, refreshing every two seconds:

Terminalwhile true; do clear; python3 ~/.agent-status/show.py; sleep 2; done

Waiting sessions sort to the top, each with its agent, project and how long it has been in that state. To see the count inside every Claude Code session as well, add a status line that runs the viewer with --count every five seconds:

~/.claude/settings.json{
  "statusLine": {
    "type": "command",
    "command": "python3 ~/.agent-status/show.py --count",
    "refreshInterval": 5
  }
}

The rough edges are the ones you’d expect from 40 lines of Python. A session that crashes never sends SessionEnd, so its file stays until you delete it. Claude Code doesn’t run Stop when you interrupt a turn, so the row can say “working” until your next prompt. After you deny a prompt, the row can say “waiting” until the next tool call or the end of the turn. And it only shows state: you still answer each agent in its own terminal. The status line guide and hooks guide cover both features in depth.

8. How to choose

• You only run Claude Code and live in the terminal: start with agent view. Running Claude Code multiple agents in the background is exactly what it was built for, and it costs nothing.
• You already use tmux: turn on bells and name your windows. Add a hook if you want the flag the moment an agent asks.
• You run many agents, or agents on other machines: Herdr gives you a terminal workspace with state for each pane and remote machines in the same sidebar.
• You want a glanceable signal in any app, free: OC-Claw in the notch.
• You wait in the browser and want to approve and reply from there: Agent Pets.
• You want exactly your own layout: the status file above, or claude agents --json if you only need Claude Code.

These mix well. Agent view or Herdr can be your desk in the terminal while Agent Pets watches the same sessions from Chrome. Whatever you pick, running parallel sessions goes more smoothly when each one has its own checkout; see parallel Claude Code sessions with git worktrees.

Questions

Does Claude Code have an agent dashboard?

Yes. Run claude agents to open agent view, a research preview that lists your background Claude Code sessions grouped Needs input, Working and Completed, with a one-line summary for each. Sessions open in other terminals appear once you background them with /bg or ←.

How do I keep track of multiple agents in Claude Code?

Send them to the background and watch them in agent view, give each one its own named tmux window with bell flags, or use a dashboard outside the terminal such as Herdr, OC-Claw or Agent Pets. Giving each session its own git worktree keeps their edits apart.

Is there an AI coding agent dashboard that covers Codex and OpenCode too?

Herdr, OC-Claw and Agent Pets all show Claude Code, Codex and OpenCode together. Herdr and OC-Claw also cover agents such as Cursor and Gemini CLI. Claude Code’s agent view only shows Claude Code.

Can I approve permission prompts from a coding agent dashboard?

From agent view, tmux and Herdr you answer in the agent’s own session or pane. Agent Pets has Allow, Always and Deny on each pet and on its desktop notification for Claude Code and OpenCode, and Allow or Deny for Codex. OC-Claw’s site shows an Approve control that we haven’t tested.

Sources: Claude Code’s documentation on agent view, hooks and the status line; Codex documentation on hooks; Herdr’s website and agents documentation; OC-Claw’s GitHub repository and website; claude agents --help on Claude Code 2.1.287.

More guides

• Claude Code multiple sessions: run and track agents in parallel
• Agent Pets vs Claude Code agent view
• Agent Pets vs Herdr
• Agent Pets vs OC-Claw
• Using Claude Code in tmux