AI Agent Fleet Operations — Bulk Actions, Real-Time Monitoring & Fleet-Level Visibility

Updated July 2026 — bulk continue, subagent monitoring, scrollback, and responsive mobile peek

amux is an open-source control plane for AI agent teams — it runs dozens of parallel Claude Code, Codex, or Gemini CLI sessions from your phone or browser with self-healing, kanban, CRM, and email built in. Once you're running 10+ agents, the individual-session mental model breaks down. You need fleet-level operations: bulk actions that apply to all agents simultaneously, fast triage to identify which sessions need attention, and deep inspection capabilities for when something goes wrong.

This guide covers the moment-to-moment work of fleet operations — reading the health view, taking bulk actions, inspecting individual agents, monitoring subagents, loading historical output, and doing all of it from your phone.

The fleet health view: reading status at a glance

The amux dashboard's main session list is your fleet overview. Each session card shows four key signals:

• Status dot — the most important signal:
  • ● Green — actively producing output; the agent is working
  • ● Yellow — idle or waiting for input; agent has paused (may need attention)
  • ● Red — error or crash; the session process has exited
• Token counter — running token spend for this session. A session spending 10× the average is either working much harder or spinning in a loop.
• Last active — time since the agent last produced output. A green-dot session that's been silent for 10+ minutes is suspicious.
• Session name and task — the current task label, scrolling horizontally if long, so you always see the full task description.

The session list updates in real time via Server-Sent Events (SSE) — all connected clients (desktop browser, iOS app, phone PWA) see the same state within ~2 seconds of any change. You can have the dashboard open on your monitor and on your phone at the same time; both stay perfectly in sync.

Fleet triage pattern: Scan for non-green dots first. If multiple sessions are yellow simultaneously, that's a signal of a systemic event — an API rate limit, a widespread context overflow, or a shared dependency that failed. A single red session is more likely an isolated crash or bug in that agent's task. Use these patterns to prioritize where to investigate first.

Bulk fleet actions: the bulk-actions modal

Individual sessions need individual attention. But some situations call for fleet-wide action — and that's what the bulk-actions modal provides. Access it from the button in the top-right toolbar of the main dashboard.

Continue all idle sessions (v0.9.78)

The most powerful fleet operation: "Continue all idle sessions" sends a "continue" message to every session currently showing a yellow (idle) status dot — all at once, with one tap.

When to use it: The morning after an overnight run is the canonical case. After 6–8 hours of unattended operation, it's common for multiple agents to have hit context limits and gone idle at roughly the same time. Previously, waking them up required clicking into each session card, finding the send bar, and typing "continue" — one session at a time. With "Continue all idle sessions," you open the app, see a fleet of yellow dots, tap one button, and they all restart simultaneously.

What it does: For each idle session, amux queues a "continue" delivery via the steering system — the same mechanism as manual sends. The message is delivered at the session's next available turn boundary, so it's safe even if a session was only briefly idle and just resumed on its own. Sessions that are actively working (green) are not affected.

What this replaced:

# Before: manually wake up 8 idle agents
for session in auth-agent feature-agent test-agent docs-agent \
               review-agent deploy-agent db-agent security-agent; do
  tmux send-keys -t "$session" "continue" Enter
done
# → 8 separate terminal operations, easy to miss one

# After: one tap in bulk-actions → "Continue all idle sessions"
# All 8 wake up simultaneously, no terminal access required

Per-agent deep inspection: the peek panel

When the fleet health view signals a problem with a specific session, the peek panel is where you investigate. Click any session card to open it.

The peek panel shows:

• Live terminal output — last 100+ lines of the agent's terminal, streaming via SSE
• Plan strip — Claude Code's native task list, rendered as a structured checklist with pending, in-progress, and completed tasks. A stale plan warning shows "plan last updated Nh ago" (v0.9.81) when the agent has deviated from or finished its original plan.
• Quick-action chips — one-tap buttons for compact, continue, and status check
• Saved messages — a library of canned prompts (per-session and global) for recurring operations
• Send bar — type any instruction, delivered at the agent's next turn boundary

See the full Claude Code monitoring guide for a complete reference on reading the plan strip and interpreting agent output.

Reading the output for fleet triage

When investigating a yellow-dot session, start at the bottom of the peek output and look for:

• Permission prompt — Do you want to proceed? or similar. Send "yes" or enable YOLO mode to auto-approve.
• Context limit message — Claude Code will say the context is full. Use the "compact" quick-action chip.
• Repeated tool calls — the same Bash( or Read( call appearing 3+ times at the bottom means the agent is looping. Send a steering message asking it to summarize what's blocking it.
• Successful completion — the agent may have finished its task and is waiting for you. Check the plan strip for all-checkmark status.

Subagent monitoring: switching between transcripts (v0.9.79)

Claude Code can spawn subagents when working on complex tasks — for instance, delegating one part of a migration to a subagent while the main agent handles another part. Before amux v0.9.79, the peek panel only showed the main agent's transcript. If a subagent was doing the actual work, you had no way to see it from the dashboard.

The subagent switcher changes this. When Claude Code spawns subagents, navigation controls appear in the peek header:

• ▲ / ▼ — cycle forward and backward through the main agent and all active subagent transcripts
• ⌂ — jump directly back to the main agent transcript at any time
• Tap ⏺/◯ agent panel rows (v0.9.83) — click any row in the agent panel to jump directly to that agent or subagent without cycling through the others

Each view shows the selected agent's complete transcript, plan strip, and send bar — you can send steering messages to individual subagents, not just the main agent.

When subagent monitoring matters most:

• Complex refactors — when Claude Code spawns subagents to handle different modules in parallel, you can verify each one is working on the right thing
• Nested agentic loops — if a subagent itself spawns sub-subagents, the switcher lets you navigate the full tree
• Debugging unexpected behavior — if the main agent's output looks fine but the task isn't progressing, switching to a subagent often reveals the actual source of the problem
• Token attribution — different subagents can consume very different amounts of tokens; inspecting their individual transcripts helps identify which one is running hot

Scrollback: loading historical output (v0.9.82)

The tmux alt-screen only holds a limited scroll buffer. For sessions that have been running for hours, output from the beginning of the session — the initial task setup, early decisions, first errors — is long gone from the terminal buffer. Previously, reading it required attaching to the terminal and using tmux's own scroll mode, which only worked at the desktop and only held so much history.

In amux v0.9.82, a "Load earlier output" bar appears at the top of the peek panel. Clicking it fetches the previous page of output from the session's persistent log file (not the tmux buffer), loading it above the current view. Each page is line-aligned, so you never see a truncated line.

The underlying mechanism:

• amux writes every session's output to a persistent log file on disk
• The peek panel paginates backward through this log using GET /api/sessions/{name}/log?before_kb=N
• The X-Log-Remaining response header tells the client how much earlier content is still available
• When X-Log-Remaining: 0, the bar disappears — you've reached the beginning of the session

Use cases for fleet operations:

• Morning diagnosis — understand what happened overnight by reading from the point where an agent went quiet, then paging backward to find the root cause
• Audit trail — verify what decisions an agent made during a complex migration before merging its changes
• Subagent history — after switching to a subagent's transcript, load its earlier output to understand how it approached its subtask from the start
• Post-incident review — after a crash and restart, read the pre-crash output to understand what the agent was doing when it failed

Responsive monitoring from your phone (v0.9.85)

Fleet operations don't stop when you leave your desk. amux is built phone-first: every feature described in this guide — the session list, bulk-actions modal, peek panel, subagent switcher, scrollback — is fully accessible from the iOS app or PWA on a 375px screen.

As of v0.9.85, the peek panel also corrects a long-standing mobile usability problem. The tmux pane running Claude Code had its width set at session creation time based on the desktop layout (~220 columns). When you opened the peek panel on a phone, Claude Code's output was hard-wrapped at 220 columns — causing double-wrapping and horizontal scrolling on the narrow screen.

The fix: the peek panel now measures the viewer's actual terminal character capacity using a font probe and sends that width to tmux via POST /api/sessions/{name}/resize. Claude Code receives the resize signal and reflows its transcript to fit. On a phone, you now see properly wrapped output — the same readability as on desktop, just narrower.

Recommended morning fleet check (from your phone):

1. Open amux iOS app or PWA
2. Scan session list — note any yellow or red dots
3. Tap bulk-actions → "Continue all idle sessions" to restart any idle agents
4. Wait 30 seconds, check that yellow dots turn green
5. Tap any red-dot sessions to check the crash reason in the peek panel
6. For sessions still yellow after "continue": tap in, read the peek output, send a steering message if needed
7. Open the kanban board to see what was completed overnight

This full check typically takes under 2 minutes from bed before you're out of the house. See Managing agents from your phone for the full mobile setup guide.

Fleet operations: with amux vs. without it

Frequently asked questions

How do I restart all idle Claude Code agents at once?

Click the bulk-actions button in the top-right dashboard toolbar and select "Continue all idle sessions" (v0.9.78). This sends a "continue" message to every session currently showing as idle (yellow status dot) simultaneously. Particularly useful in the morning after an overnight run.

Can I see what Claude Code subagents are doing?

Yes. Amux v0.9.79 added a subagent transcript switcher to the peek panel. When Claude Code spawns subagents, ▲/▼ navigation buttons appear. Tap them to cycle through each subagent's transcript, or tap ⏺/◯ agent panel rows (v0.9.83) to jump directly. The ⌂ button returns to the main transcript.

How do I see historical output from a long Claude Code session?

Use the "Load earlier output" bar at the top of the peek panel (v0.9.82). It pages backward through the session's persistent log file, loading older output above the live view. Keep clicking to reach the beginning of the session. Works on phone and desktop, no terminal attachment needed.

Can I manage my agent fleet from my phone?

Yes. The amux iOS app and PWA provide the full fleet operations surface on any screen size. As of v0.9.85, the peek panel reflows to your phone's character width — no double-wrapping. Use Tailscale for secure remote access from anywhere, or amux tunnel for a public HTTPS URL.

What does the status dot color mean?

Green = actively working. Yellow = idle or waiting for input (needs attention or just finished). Red = crashed or errored. The self-healing watchdog auto-restarts red sessions if configured. For yellow sessions, use "Continue all idle sessions" from the bulk-actions modal.

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

• Running 10+ AI coding agents in parallel
• Claude Code monitoring — plan strip, peek panel, and live output
• Self-healing agent configuration
• Managing agents from your phone
• Kanban board for AI agents
• AI coding while you sleep
• Run Claude Code in the background — amux start --detach