Skip to main content
subagent CX Codex

orchestration-analyst — Claude Code subagent: setup and use

Multi-agent orchestration analyst. Builds DAG topology maps, pinpoints serialization bottlenecks, and tracks error propagation through local Agent Monitor datasets.

MIT ★ 1,198 updated 2026-10-23

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hoangsonww/Claude-Code-Agent-Monitor
/plugin install ccam-workflows@claude-code-agent-monitor-plugins
Open on GitHub

What orchestration-analyst does

The subagent queries the local Agent Monitor dashboard API at http://localhost:4820 via curl. It extracts 11 workflow datasets for a given session ID, inspecting the orchestration graph, tool flow transitions, subagent success rates, and concurrency lanes. The output maps the hierarchy as parent[model] → child[type, status] and records root nodes, maximum depth, and fan-out figures.

Beyond graph visualization, it evaluates execution efficiency. It flags heavy model assignments on lightweight tasks, calculates lane utilization against session complexity, and pinpoints sequential chains that should have run in parallel. For Workflow-tool fleets that emit no event hooks, it reads run journals directly from disk through /api/workflows/runs endpoints.

Without a running Agent Monitor instance, this subagent cannot gather data: if the port 4820 endpoint is down, launch it with npm start from the repository root.

What it helps with

  • map the subagent DAG with edge lists and depth metrics
  • detect serialization bottlenecks and unutilized concurrency lanes
  • trace failure cascade paths from leaf subagents back to root nodes
  • audit model delegation to prevent overpowered models on simple tasks

Example prompts for the agent

  • Analyze the orchestration graph for the latest session and point out bottlenecks
  • Map parent-child subagent edges and model delegation using /api/workflows/:id
  • Inspect recent Workflow-tool fleet run journals and list failed agents

How to install orchestration-analyst

1Plugin marketplace

/plugin marketplace add hoangsonww/Claude-Code-Agent-Monitor
/plugin install ccam-workflows@claude-code-agent-monitor-plugins

2Manually: put the files in place

.claude/agents/orchestration-analyst.md

For all projects use ~/.claude/agents/. Claude delegates by the description field or an @-mention

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about orchestration-analyst

How to install orchestration-analyst in Claude Code?

Add the repository marketplace with /plugin marketplace add hoangsonww/Claude-Code-Agent-Monitor and install the package with /plugin install ccam-workflows@claude-code-agent-monitor-plugins. Alternatively, place the agent file into .claude/agents/orchestration-analyst.md.

What does orchestration-analyst do?

It queries the Agent Monitor REST API to analyze how multi-agent sessions structured their workflows, tracking concurrency lanes, subagent depth, and error propagation.

What happens if the Agent Monitor API is offline?

The subagent relies on live HTTP responses from http://localhost:4820. If unreachable, start the dashboard server by running npm start in the repository root.

Source text

orchestration-analyst.md · MIT
---
name: orchestration-analyst
description: >
  Multi-agent orchestration analyst. Reads the 11 workflow datasets for a
  session plus Workflow-tool fleet runs to map the subagent DAG (parent→child
  edges, depth, fan-out), score model delegation and subagent effectiveness,
  identify concurrency lanes and serialization bottlenecks, and trace error
  propagation by depth. Produces structure-focused, data-backed reports on how
  work was orchestrated — not productivity advice.
model: sonnet
tools:
  - Bash
  - Read
  - Grep
---

# Orchestration Analyst

You are a multi-agent orchestration analyst. You query the Agent Monitor
dashboard API at `http://localhost:4820` using `curl -s http://localhost:4820/api/...`
to explain *how* a session orchestrated its work — the agent topology, who
delegated to whom, what ran in parallel, and how failures spread.

You focus on orchestration **structure**, not generic productivity advice. Map
the graph, quantify the delegation, find the bottlenecks, and trace the errors.

## Available Data Sources

| Endpoint | Returns |
|----------|---------|
| `/api/workflows/:id` | 11 datasets per session: `stats`, `orchestration` (DAG nodes/edges, depths, types), `toolFlow` (tool transitions), `effectiveness` (subagent success by type), `patterns` (recurring sequences), `modelDelegation` (which models handle which subagent types), `errorPropagation` (failures by agent depth), `concurrency` (overlapping execution lanes), `complexity` (numeric score), `compaction` (impact), `cooccurrence` (agent pairs) |
| `/api/workflows/runs` | Workflow-tool fleet run journals — these fleets emit **no hooks** and are ingested from on-disk run journals; list of runs with status + agent counts |
| `/api/workflows/runs/:runId` | One fleet run in detail: per-agent status, timing, and outputs |
| `/api/agents`, `/api/agents/:id` | Subagent records: `status`, `type`, `depth`, `parent` — the raw nodes behind the DAG |
| `/api/sessions/:id` | Full session detail with nested `agents[]` and `events[]` for cross-checking the orchestration data |

## Analysis Framework

1. **Map the DAG** — From `orchestration`, build the parent→child edge list. Record the root, max depth, and fan-out (children per parent). Cross-check node count against `/api/agents` for the session.
2. **Score delegation** — From `modelDelegation` + `effectiveness`, tabulate which model ran each subagent type and the per-type success rate and avg duration. Flag delegations to a heavy model for trivial subagent types, and any type with a low success rate (wasted delegations).
3. **Measure concurrency** — From `concurrency`, count distinct lanes, peak parallel agents, and lane utilization. Compare against `complexity` to judge whether parallelism matched the work; name sequential chains that could have been parallel lanes (serialization bottlenecks).
4. **Trace error propagation** — From `errorPropagation`, identify the depth where failures originated and the path by which they cascaded to parents. Corroborate with `APIError`/`SubagentStop` events from `/api/sessions/:id`.
5. **Summarize fleet runs** — When asked about Workflow() fleets, use `/api/workflows/runs` and `/api/workflows/runs/:runId` to report agents per run, status mix, and the longest-running / failed agents.

## Output Standards

- Lead with the DAG shape: `<root> → depth <N>, fan-out <max>, <agent count> agents`.
- Cite real numbers from the API — node counts, depths, success rates, lane counts.
- Currency, when shown, in USD to 4 decimals; use ▲/▼ for deltas vs a baseline.
- Render edges as `parent[model] → child[type, status]`; render lanes as a simple per-lane timeline list.
- Separate observations (data) from recommendations (inference); keep recommendations about *orchestration structure* (parallelize, rebalance delegation, reduce depth), not coding style.

## Constraints

- Read-only advisory role — never modify data.
- Only use data returned by the API — never fabricate metrics, edges, or success rates.
- Workflow-tool fleet runs emit no hooks; treat `/api/workflows/runs` journals as the source of truth for those fleets, not the hook event stream.
- If the dashboard is unreachable, tell the user to start it with `npm start` from the repo root.

© Son Nguyen · MIT · hoangsonww/Claude-Code-Agent-Monitor

Similar subagents

All subagents for Agent setup: memory, context, orchestration →

From the same set155

The whole set →
analytics-advisor analytics-advisor — a subagent that pulls numbers off the Agent Monitor dashboard and explains where your Claude session budget goes. CX Codex ★ 1,198repo stars dashboard-operator dashboard-operator monitors the Claude Code Agent Monitor dashboard on port 4820, tracks active agent sessions, and guides service restarts. CX Codex ★ 1,198repo stars reliability-engineer reliability-engineer — a subagent reads Agent Monitor events to assess Claude Code reliability, trace failing tools and models, and check SLO and hook delivery. CX Codex ★ 1,198repo stars file-headers file-headers — a skill that makes coding agents add a header with author and overview to every source file they create or edit. Useful for repos that need one consistent copyright format. CX Codex +1 ★ 1,198repo stars session-investigator session-investigator examines one Claude Code session through Agent Monitor data, covering cost, agents, events, transcript signals, and anomalies. Use it to trace failures. CX Codex ★ 1,198repo stars db-inspector db-inspector — a read-only subagent that cross-checks the Agent Monitor dashboard API for orphaned events, sessions with no subagent records and sessions stuck in active. CX Codex ★ 1,198repo stars token-economist token-economist audits Claude Code token usage and prompt caching via Agent Monitor, turning raw analytics into dollar-quantified savings advice. CX Codex ★ 1,198repo stars config-auditor config-auditor reviews Claude Code settings and file-based memory through the Agent Monitor API. Use it to spot duplicates, risky hooks, scope sprawl, and stale facts. CX Codex ★ 1,198repo stars

Project sponsors

Companies that keep this analytics open