Orchestrator

Skill stotihv/skills/skills/orchestrator

🤖 Coordinate multi-agent tasks and enhance workflow with versatile skills for autonomous planning and execution.

Install

npx -y skills add stotihv/skills --skill orchestrator

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Plan and coordinate multi-agent bead execution. Use when starting a new epic, assigning tracks to agents, or monitoring parallel work progress.

SKILL.md

10.7 KB, ~2.3k tokens by cl100k_base, as published. Nobody here has run it

Orchestrator Skill: Autonomous Multi-Agent Coordination

This skill spawns and monitors parallel worker agents that execute beads autonomously.

Prerequisite: Run the planning skill first to generate history/<feature>/execution-plan.md.

Architecture (Mode B: Autonomous)

┌─────────────────────────────────────────────────────────────────────────────┐
│                              ORCHESTRATOR                                   │
│                              (This Agent)                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│  1. Read execution-plan.md (from planning skill)                            │
│  2. Initialize Agent Mail                                                   │
│  3. Spawn worker subagents via Task tool                                    │
│  4. Monitor progress via Agent Mail                                         │
│  5. Handle cross-track blockers                                             │
│  6. Announce completion                                                     │
└─────────────────────────────────────────────────────────────────────────────┘
           │
           │ Task tool spawns parallel workers
           ▼
┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
│  BlueLake        │  │  GreenCastle     │  │  RedStone        │
│  Track 1         │  │  Track 2         │  │  Track 3         │
│  [a → b → c]     │  │  [x → y]         │  │  [m → n → o]     │
├──────────────────┤  ├──────────────────┤  ├──────────────────┤
│  For each bead:  │  │  For each bead:  │  │  For each bead:  │
│  • Reserve files │  │  • Reserve files │  │  • Reserve files │
│  • Do work       │  │  • Do work       │  │  • Do work       │
│  • Report mail   │  │  • Report mail   │  │  • Report mail   │
│  • Next bead     │  │  • Next bead     │  │  • Next bead     │
└──────────────────┘  └──────────────────┘  └──────────────────┘
           │                   │                   │
           └───────────────────┼───────────────────┘
                               ▼
                    ┌─────────────────────┐
                    │     Agent Mail      │
                    │  ─────────────────  │
                    │  Epic Thread:       │
                    │  • Progress reports │
                    │  • Bead completions │
                    │  • Blockers         │
                    │                     │
                    │  Track Threads:     │
                    │  • Bead context     │
                    │  • Learnings        │
                    └─────────────────────┘

Phase 1: Read Execution Plan

Use the Read tool to load the execution plan:

path: history/<feature>/execution-plan.md

Extract:

EPIC_ID - the epic bead id
TRACKS - array of {agent_name, beads[], file_scope}
CROSS_DEPS - any cross-track dependencies

Phase 2: Initialize Agent Mail

Step 1: Ensure project exists

Tool: mcp__mcp_agent_mail__ensure_project

Parameter	Value
`human_key`	`<absolute-project-path>`

Step 2: Register orchestrator identity

Tool: mcp__mcp_agent_mail__register_agent

Parameter	Value
`project_key`	`<absolute-project-path>`
`name`	`<OrchestratorName>` (e.g. `GoldFox`)
`program`	`amp`
`model`	`<model>`
`task_description`	`Orchestrator for <epic-id>`

Phase 3: Spawn Worker Subagents

Spawn all workers in parallel using the Task tool.

For each track, invoke:

Tool: Task

Parameter	Value
`description`	`Worker <AgentName>: Track N - <description>`
`prompt`	See `reference/worker-template.md`

Example Task prompt for Track 1

You are agent BlueLake working on Track 1 of epic bd-42.

## Setup
1. Read /path/to/project/AGENTS.md for tool preferences
2. Load the worker skill: skill worker

## Your Track
Beads to complete IN ORDER: bd-43, bd-44, bd-45
File scope: packages/sdk/**

## Protocol for EACH bead:

### Start Bead
1. mcp__mcp_agent_mail__register_agent with name="BlueLake", task_description="<bead-id>"
2. mcp__mcp_agent_mail__summarize_thread with thread_id="track:BlueLake:bd-42"
3. mcp__mcp_agent_mail__file_reservation_paths with paths=["packages/sdk/**"], reason="<bead-id>"
4. Run: bd update <bead-id> --status in_progress

### Work on Bead
- Use preferred tools from AGENTS.md (gkg for exploration, morph for edits)
- Check inbox periodically with mcp__mcp_agent_mail__fetch_inbox

### Complete Bead
1. Run: bd close <bead-id> --reason "Summary of work"
2. mcp__mcp_agent_mail__send_message:
   - to: ["GoldFox"]
   - thread_id: "bd-42"
   - subject: "[<bead-id>] COMPLETE"
   - body_md: "Done: <summary>. Next: <next-bead-id>"
3. mcp__mcp_agent_mail__send_message (context for next bead):
   - to: ["BlueLake"]
   - thread_id: "track:BlueLake:bd-42"
   - subject: "<bead-id> Complete - Context for next"
   - body_md: "## Learnings\n- ...\n## Gotchas\n- ..."
4. mcp__mcp_agent_mail__release_file_reservations

### Continue to Next Bead
- Loop back to "Start Bead" with next bead in track
- Read your track thread for context from previous bead

## When Track Complete
mcp__mcp_agent_mail__send_message:
- to: ["GoldFox"]
- thread_id: "bd-42"
- subject: "[Track 1] COMPLETE"
- body_md: "All beads done. Summary: ..."

Return a summary of all work completed.

Phase 4: Monitor Progress

While workers execute, monitor via Agent Mail.

Check Epic Thread for Updates

Tool: mcp__mcp_agent_mail__search_messages

Parameter	Value
`project_key`	`<path>`
`query`	`<epic-id>`
`limit`	`20`

Check for Blockers

Tool: mcp__mcp_agent_mail__fetch_inbox

Parameter	Value
`project_key`	`<path>`
`agent_name`	`<OrchestratorName>`
`urgent_only`	`true`
`include_bodies`	`true`

Check Bead Status

bv --robot-triage --graph-root <epic-id> 2>/dev/null | jq '.quick_ref'

Phase 5: Handle Cross-Track Issues

If Worker Reports Blocker

Tool: mcp__mcp_agent_mail__reply_message

Parameter	Value
`project_key`	`<path>`
`message_id`	`<blocker-msg-id>`
`sender_name`	`<OrchestratorName>`
`body_md`	`Resolution: ...`

If File Conflict

Tool: mcp__mcp_agent_mail__send_message

Parameter	Value
`project_key`	`<path>`
`sender_name`	`<OrchestratorName>`
`to`	`["<HolderAgent>"]`
`thread_id`	`<epic-id>`
`subject`	`File conflict resolution`
`body_md`	`<Worker> needs <files>. Can you release?`

Phase 6: Epic Completion

When all workers report track complete:

Verify All Done

bv --robot-triage --graph-root <epic-id> 2>/dev/null | jq '.quick_ref.open_count'
# Should be 0

Send Completion Summary