How to Monitor Claude Code Agents — See What Your Agent Is Doing

Updated July 2026 — real-time plan visibility, session peek, and mobile monitoring for Claude Code

When you run a Claude Code agent on a long task, you often have no idea what it's actually doing. It's working in a tmux terminal you've minimized, and unless you attach to that terminal, you're flying blind. You don't know whether it's making progress, waiting for a prompt, spinning in a loop, or has already finished and is waiting for you. amux solves this with a real-time monitoring layer: a session peek panel that streams live output and a plan strip that reads Claude Code's own task list and surfaces it as structured, human-readable progress.

The problem with monitoring Claude Code

Claude Code is a powerful coding agent, but its default monitoring story is minimal. It runs in a terminal, produces text output, and you watch it scroll. That works fine for a single short task you're sitting in front of. It breaks down as soon as you:

• Run agents on tasks that take more than a few minutes
• Run more than one agent at a time
• Walk away from your computer — to a meeting, to sleep, to anything else
• Want to check on progress from your phone
• Need to understand the agent's plan before it executes it

The raw terminal gives you a fire hose of output with no structure. You can't tell at a glance whether the agent is on step 2 of 8 or whether it got stuck on step 2 an hour ago and has been retrying ever since. You can't peek at it from another device without setting up SSH tunneling or tmux sharing. And when you run 10 or more agents in parallel, checking each terminal individually is completely untenable.

amux adds a structured monitoring layer on top of Claude Code's raw output. Two features matter most: the session peek panel for live output, and the plan strip for structured task progress.

The plan strip: see exactly what your agent is working on

Introduced in amux v0.9.44, the plan strip is a read-only view that lives inside the session peek panel. It reads Claude Code's native internal task list and renders it as a structured, scannable strip showing three categories of tasks:

• Completed tasks — shown with a checkmark; what the agent has already finished
• Current task — the step the agent is actively working on right now, highlighted
• Pending tasks — what's coming next in the agent's plan

The strip updates in real time as the agent progresses through its plan. You don't need to parse terminal output to understand where the agent is — the plan strip gives you a structured view of intent and progress simultaneously.

Claude Code internally maintains a task list when working on multi-step problems. The plan strip reads this through amux's server endpoint:

GET /api/sessions/{name}/plan

The response is structured JSON you can also consume programmatically — useful for piping into CI dashboards, scripts that trigger on task completion, or custom monitoring tooling.

A typical plan for an agent working on a feature might look like this in the strip:

✓ Read and understand existing auth module
✓ Identify files that need to change
▶ Implement OAuth refresh token rotation        ← current
  Write unit tests for the new behavior
  Update CHANGELOG and docs
  Open draft PR

That's the difference between monitoring and visibility. You're not watching a fire hose — you're reading a structured plan with a progress indicator.

Real-time output: the session peek panel

The plan strip shows you what the agent is doing. The peek panel shows you how it's doing it.

Click any session card in the amux dashboard and the peek panel opens on the right (or slides up on mobile). It shows:

• Live terminal output — the last 100+ lines of the agent's terminal, streaming in real time via Server-Sent Events. No manual refresh; you see updates within ~2 seconds.
• Plan strip — structured task list, pinned above the output stream for quick orientation
• Quick-action chips (v0.9.46) — one-tap buttons for common steering actions: compact, continue, status check. No typing required.
• Saved messages (v0.9.47) — a modal with canned prompts you've saved, organized by "This session" and "All sessions." Send a saved prompt with one tap — useful for recurring actions like "summarize current state", "open a draft PR", or "pause and wait for review."
• Send bar — type any instruction and deliver it to the agent via the steering queue, which batches delivery at the agent's next turn boundary so you don't interrupt mid-thought.
• Schedules badge (v0.9.45) — a color-coded indicator showing whether the session has active schedules attached. Green = running, gray = none.

The peek panel is the primary interaction surface for a running agent. Most monitoring and light steering happens here without ever touching a terminal.

Reading the output effectively

Claude Code's output can be verbose. When you open the peek panel, orient yourself by reading the bottom of the output first — that's where the most recent activity is. Look for:

• Lines starting with → or ✓ — Claude Code's own task completion markers
• Tool call patterns — Read(, Write(, Bash( — showing what the agent is doing
• Wait indicators — Waiting for permission... or permission prompts that haven't been answered
• Error patterns — stack traces, Error: lines, or repeated retries of the same operation

If you see the same tool call repeated 3+ times at the bottom of the output, the agent is likely stuck. Use the quick-action chips or the send bar to unstick it.

Monitoring multiple agents at once: the dashboard board

When you're running a fleet of agents, the dashboard's main session list is your fleet overview. Each session card shows:

• Status dot — green (actively producing output), yellow (idle / waiting for input), red (error or crashed)
• Session name — and any long task names, which now scroll horizontally instead of truncating (v0.9.48), so you see the full context
• Token counter — running token spend for this session, useful for spotting runaway sessions
• Last active — how long ago the agent last produced output. A session that's been silent for 10+ minutes and not in a "waiting" state deserves a look.

The main view updates in real time via SSE — all connected clients (desktop, phone, tablet) see the same state within ~2 seconds of any change. You can have the dashboard open on your monitor and on your phone simultaneously; both stay in sync.

Combine the session list with the kanban board for a complete picture of fleet progress:

• The session list shows agent health — which are running, which are stuck, which need attention
• The kanban board shows task progress — which tasks are in todo, doing, and done, and which agent owns each

Together they answer the two questions you always have when running a fleet: "Is everyone working?" and "What has actually shipped?"

From your phone: mobile monitoring

amux is built phone-first. The monitoring surface described above — peek panel, plan strip, quick-action chips, saved messages, session list — is fully accessible on a 375px screen. Touch targets meet the 44×44px minimum; the layout reflows for mobile; the iOS PWA installs to your home screen for native-feeling access.

For the smoothest mobile experience, use the native iOS app (App Store: amux – Agent Multiplexer). It connects to your local amux server over your home network or via Tailscale for remote access. Key mobile monitoring flows:

• Morning check: open the app, scan the session list for any red/yellow dots from the overnight run, tap into any concerning session to read its plan strip and last output
• Mid-meeting check: pull out your phone, glance at the session list — if everything is green, you don't need to think about it; if something is yellow or red, open the peek panel and send a quick instruction with a saved message chip
• Approval from anywhere: if an agent hits a permission prompt it can't auto-approve, you'll see the session go yellow. Tap in, read the prompt in the output, and send approval via the send bar — all without returning to your desk.

For a full guide to mobile agent management, see AI coding while you sleep.

What to do when an agent goes quiet

An agent that has stopped producing output is one of the most common situations you'll encounter. There are several distinct causes, each with a different resolution:

Waiting for a permission prompt

Claude Code in non-YOLO mode pauses and waits for you to approve certain actions. Open the peek panel and scroll to the bottom — if you see a permission prompt, send "yes" or "approve" via the send bar, or configure YOLO mode to auto-approve for trusted contexts.

Context window full

When the context window fills, Claude Code stops. The output will contain a message about the context limit. Use the "compact" quick-action chip in the peek panel to trigger /compact, which summarizes the context and continues. amux's self-healing watchdog can auto-compact on context overflow if configured.

Genuinely stuck in a loop

Sometimes an agent retries the same operation repeatedly without making progress. Check the plan strip — if the current task hasn't changed and the output shows repeated tool calls, the agent is looping. Send a steering message: "You appear to be stuck on [task]. Stop retrying and summarize what you've tried and what's blocking you." Then decide whether to give it new information or take a different approach manually.

Task is complete but agent is waiting

Check the plan strip — if all tasks show as completed, the agent may have finished and is waiting for you to review. Look at the output for a summary or a prompt for next steps. The session status dot will typically be yellow (waiting) rather than green (active) in this case.

Process crash

The session status dot goes red. The amux watchdog detects the exit and can auto-restart the session, replaying the last message so the agent picks up where it left off. Enable this in your self-healing configuration.

Monitoring with amux vs. without it

Frequently asked questions

How do I see what my Claude Code agent is doing right now?

Open the amux dashboard at https://localhost:8822 (or the iOS app) and click any session card. The peek panel opens with live streaming output and the plan strip showing the agent's current task list. No terminal needed.

What is the Claude Code plan strip?

The plan strip (v0.9.44) is a structured view inside the amux peek panel that reads Claude Code's native task list. It displays completed tasks, the current in-progress task, and pending tasks — updated in real time as the agent works. The raw data is available at GET /api/sessions/{name}/plan.

Can I monitor agents from my phone?

Yes. The amux dashboard is a phone-optimized PWA and there's also a native iOS app. You can view live output, read the plan strip, send instructions, and manage the board from a 375px screen.

What do I do when an agent stops producing output?

Open the peek panel and check the last few lines of output. Common causes: waiting for a permission prompt (send "yes"), context window full (use the compact chip), genuinely stuck (send a steering message asking it to report its current state), or crashed (the watchdog auto-restarts if configured). See the full decision tree in the "What to do when an agent goes quiet" section above.

How do I monitor 10 agents at once without going crazy?

The dashboard session list gives you a fleet overview at a glance via color-coded status dots. You only need to open the peek panel for sessions that show yellow (waiting) or red (error). For task-level tracking across the fleet, the kanban board shows who owns what and what's been completed.

Is there an API to read agent plan data programmatically?

Yes: GET /api/sessions/{name}/plan returns structured JSON with the agent's task list including status for each task (pending, in_progress, completed). Useful for CI integration, custom dashboards, or scripts that trigger on task completion.

git clone https://github.com/mixpeek/amux && cd amux && ./install.sh
amux register myproject --dir ~/Dev/myproject --yolo
amux start myproject
amux serve  # → https://localhost:8822

Related guides

• Getting started with amux
• Running 10+ AI coding agents in parallel
• Self-healing agent configuration
• Setting up YOLO mode
• Managing agents from your phone
• Kanban board for AI agents
• AI coding while you sleep