# Agent Orchestra

> Multi-agent fleet conductor for the GitHub Copilot CLI. Launches exactly five visible Terminal Stampede commander groups, coordinates them through live collaboration ledgers, watches them with Agent Pulse, and applies sealed Shadow Score evaluation. Say "agent orchestra" to start.

- Skill: `dubsopenhub/agent-orchestra` (Agent Skill)
- Install (CLI): `npx skillmds@latest add dubsopenhub/agent-orchestra`
- Raw SKILL.md: https://api.skillmd.com/api/skills/dubsopenhub/agent-orchestra/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: DUBSOpenHub (https://skillmd.com/u/dubsopenhub)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/dubsopenhub/agent-orchestra

---


# Agent Orchestra

Agent Orchestra coordinates exactly five commander-led groups for high-stakes
repo work. Each commander owns one deterministic manifest, may launch bounded
sub-agents, collaborates through append-only ledgers, writes live telemetry for
Agent Pulse, and emits a terminal bundle for Shadow Score and Fleet Scorecard
synthesis.

Use user-facing terminology **sub-agents**. The compatibility ledger filename
`child-agents.jsonl` may appear in paths, but responses should say
**sub-agents**.

## Command Grammar

| Pattern | Action |
|---|---|
| `agent orchestra` | Ask only for missing mission/repo; default to Premium Max + Agent Pulse + Stampede monitor |
| `agent orchestra on REPO : MISSION` | Launch with Premium Max + Agent Pulse + Stampede monitor unless tier/scale are explicit |
| `agent orchestra premium max on REPO : MISSION` | Launch five premium commander groups with Agent Pulse + Stampede monitor |
| `agent orchestra standard small on REPO : MISSION` | Launch five standard-tier commander groups with Agent Pulse + Stampede monitor |
| `agent orchestra status [RUN_ID]` | Show concise run stats, commander health, collaboration counts, and decision |
| `agent orchestra teardown RUN_ID` | Stop the underlying Stampede tmux session and synthesize terminal bundles |
| `agent orchestra pulse` | Open Agent Pulse scoped to the target repo |

Default repo is the current working directory. Mission text after `:` is
required for a launch.

## Defaults

- `model_tier`: `premium`
- `scale`: `max`
- `commander_count`: `5`
- `dashboard`: `Agent Pulse + Stampede monitor`

Do not ask tier, scale, or dashboard questions when absent. Ask only one
question at a time for missing launch inputs:

1. Ask for mission when no text after `:` was provided.
2. Ask for repo only when no `on REPO` was provided and the current working
   directory is not the intended target or is not a usable git repository.

Every Agent Orchestra metaswarm run launches exactly five commanders:
`commander-001` through `commander-005`. Never silently downscale. If five
commanders cannot launch, mark the run `partial` or `failed` and explain why.

## Model Tiers

Premium rotation:

```text
claude-opus-4.7,gpt-5.5,claude-opus-4.6,gpt-5.4,claude-opus-4.5,claude-sonnet-4.6,gpt-5.3-codex,claude-sonnet-4.5
```

Standard rotation:

```text
claude-sonnet-4.6,gpt-5.4,claude-sonnet-4.5,gpt-5.3-codex
```

Never silently use cheap or mini models for Agent Orchestra sub-agents:

```text
claude-haiku-4.5,gpt-5.4-mini,gpt-5-mini,gpt-4.1
```

## SQL Tracking

Initialize these tables on every invocation:

```sql
CREATE TABLE IF NOT EXISTS agent_orchestra_runs (
    run_id TEXT PRIMARY KEY,
    repo_path TEXT NOT NULL,
    mission TEXT NOT NULL,
    model_tier TEXT NOT NULL,
    scale TEXT NOT NULL,
    commander_count INTEGER NOT NULL,
    status TEXT DEFAULT 'running',
    created_at TEXT DEFAULT (datetime('now')),
    updated_at TEXT DEFAULT (datetime('now'))
);

CREATE TABLE IF NOT EXISTS agent_orchestra_events (
    run_id TEXT NOT NULL,
    ts TEXT DEFAULT (datetime('now')),
    event TEXT NOT NULL,
    detail TEXT
);
```

## Preflight

Before launch, verify the local hardened runtime exists:

```bash
command -v copilot
command -v tmux
command -v python3
command -v git
test -x ~/bin/stampede.sh
test -x ~/bin/stampede-monitor.sh
grep -q "stampede_synthesize_commander_bundle" ~/bin/stampede.sh
grep -q "Your exact commander task is pre-claimed" ~/bin/stampede.sh
grep -q "requires exactly 5 commanders" ~/bin/stampede.sh
```

If the launcher or monitor is missing, stop and tell the user to run the Agent
Orchestra installer from `https://github.com/DUBSOpenHub/agent-orchestra`. If a
hardened-launcher marker is missing, stop before launch and reinstall; stale
launchers can start panes without deterministic pre-claim or terminal bundle
synthesis.

## Run Layout

Agent Orchestra stores coordination inside the target repo:

```text
REPO/.stampede/RUN_ID/
  state.json
  fleet.json
  queue/
  claimed/
  results/
  commanders/commander-###/
    manifest.json
    context-capsule.json
    assignments.json
    swarm-state.json
    child-agents.jsonl
    bundle.json
    atoms/
    logs/
  collab/
    protocol.json
    proposals.jsonl
    reviews.jsonl
    improvements.jsonl
    consensus.jsonl
    broadcasts.jsonl
  shadow-score/
    sealed/criteria.json
    seal.sha256
  orchestrator-commentary.json
  orchestrator-commentary.jsonl
```

## Launch Workflow

1. Parse repo, mission, model tier, and scale.
2. Create `run-YYYYMMDD-HHMMSS` under `REPO/.stampede/`.
3. Write `state.json` with `product: "agent-orchestra"`,
   `profile: "metaswarm"`, `commander_count: 5`, model tier, repo path, and
   mission.
4. Create a sealed Shadow Score envelope before commanders start. Hash
   `shadow-score/sealed/criteria.json` into `shadow-score/seal.sha256`.
5. Create the collaboration bus ledgers:
   `proposals.jsonl`, `reviews.jsonl`, `improvements.jsonl`, `consensus.jsonl`,
   and `broadcasts.jsonl`.
6. Ensure exactly five commander manifests exist and each has matching
   `task_id` and `commander_id`.
7. Launch Terminal Stampede with metaswarm mode:

```bash
STAMPEDE_OBJECTIVE="$MISSION" \
STAMPEDE_METASWARM_NO_GATES=1 \
STAMPEDE_MODEL_POLICY="$MODEL_TIER" \
STAMPEDE_PREMIUM_MODEL_POOL="$MODEL_POOL" \
STAMPEDE_BANNED_CHILD_MODELS="claude-haiku-4.5,gpt-5.4-mini,gpt-5-mini,gpt-4.1" \
STAMPEDE_SQUAD_LEADS_PER_COMMANDER=50 \
STAMPEDE_WORKERS_PER_SQUAD_LEAD=5 \
STAMPEDE_WORKERS_PER_COMMANDER=250 \
~/bin/stampede.sh \
  --metaswarm \
  --run-id "$RUN_ID" \
  --count 5 \
  --repo "$REPO_PATH" \
  --models "$MODEL_POOL" \
  --no-attach
```

8. Open Agent Pulse scoped to the repo:

```bash
osascript -e 'tell application "Terminal" to do script "cd ~/copilot-cli-agent-pulse && AGENT_PULSE_SCAN_ROOTS='"$REPO_PATH"' python3 agent_pulse.py --no-splash"' \
  -e 'tell application "Terminal" to activate'
```

## Status Output

For status, read:

- `orchestrator-commentary.json`
- `fleet.json`
- `commanders/*/swarm-state.json`
- `commanders/*/child-agents.jsonl`
- `collab/*.jsonl`
- `results/commander-*.json`

Use this compact shape:

```text
AGENT ORCHESTRA — EXECUTION
RUN run-...  STATUS running|partial|failed|stopped

Commander       Model              Phase                Sub-agents        State
commander-001   claude-opus-4.7    launching_workers    120/250          active
commander-002   gpt-5.5            complete             250/250          success

Totals: cmd 2/5 active · sub-agents 42 running / 370 done / 620 seen · results 3/5
Decision: wait | stop | synthesize partial | relaunch
```

Expected terminal bundle count is always exactly five. If fewer than five
result bundles exist, report `running`, `partial`, or `failed`; do not begin
final synthesis.

## Teardown

For teardown:

```bash
~/bin/stampede.sh --teardown --run-id "$RUN_ID" --repo "$REPO_PATH"
```

Report process cleanup, tmux session state, queue/claim counts, result bundle
count, and final run state.

## Final Synthesis and Shadow Score

After exactly five `results/commander-*.json` bundles exist:

1. Verify each result filename, `task_id`, and `commander_id` match.
2. Verify each commander has launch proof in `swarm-state.json` and
   `child-agents.jsonl`; missing proof prevents `success`.
3. Load collaboration ledgers.
4. Recompute and verify the sealed Shadow Score hash.
5. Score requirement coverage, collaboration quality, evidence quality,
   test/validation impact, and synthesis usefulness.
6. Write `shadow-score/scorecard.json`.
7. Produce a concise final answer with commander status, collaboration stats,
   Shadow Score summary, best findings, caveats, and next action.

Do not expose sealed criteria while a run is active.

