What is orchestration?

A multi-agent coordination approach that runs tasks as a named team, with defined lifecycle from TeamCreate to shutdown.

How should I size the team?

Choose 2-3 for small, independent tasks; 4-6 for multi-domain plans; 7+ for large Opus-scale coordination, following the pattern guidance.

How do I finish and shut down?

When all tasks complete (or abort), send shutdown_request to each member and perform a final wave merge if needed.

orchestration

Scanned

npx machina-cli add skill Roberdan/MyConvergio/orchestration --openclaw

Files (1)

SKILL.md

3.2 KB

Multi-Agent Orchestration via Agent Teams

When to Use

Complex tasks with 4+ independent subtasks
Release preparations with multiple verification steps
Large refactoring across multiple file domains
Any plan created by strategic-planner agent

Team Lifecycle

TeamCreate → TaskCreate (assign) → SendMessage → execute → shutdown

Create team: TeamCreate with named members (agents by name)
Create tasks: TaskCreate per subtask with title, description, assigned agent
Assign work: SendMessage to each member with task context
Monitor: TaskList to track progress
Update: TaskUpdate when status changes
Shutdown: SendMessage type: shutdown_request to each member

Example Team Creation Pattern

TeamCreate: "plan-{id}-executors" with members [baccio, marco, luca, rex]

TaskCreate: title="T-01: API refactor", assignee=baccio, description="Refactor src/api/"
TaskCreate: title="T-02: Component update", assignee=marco, description="Update src/components/"
TaskCreate: title="T-03: Tests", assignee=luca, description="Write unit tests"
TaskCreate: title="T-04: DB migration", assignee=rex, description="Run migrations"

SendMessage: to baccio → "Execute T-01: Refactor src/api/ per plan specs"
SendMessage: to marco → "Execute T-02: Update src/components/ per plan specs"
SendMessage: to luca → "Execute T-03: Write tests for updated components"
SendMessage: to rex → "Execute T-04: Run DB migrations and verify schema"

Shutdown Protocol

When all tasks are done or on abort:

SendMessage: to baccio → type: shutdown_request
SendMessage: to marco → type: shutdown_request
SendMessage: to luca → type: shutdown_request
SendMessage: to rex → type: shutdown_request

Pattern Selection

Workers	Pattern	Use When
2-3	Small team	Independent parallel tasks
4-6	Swarm	Multi-domain plan execution
7+	Mega-swarm	Opus coordinator + TeamCreate

Task Assignment Rules

NO FILE OVERLAP - Assign disjoint file sets per agent
WORKTREE MANDATORY - Each agent must use wave worktree (not main)
TDD per task - Each agent follows RED → GREEN workflow
Thor per task - plan-db.sh validate-task before marking done

Integration with strategic-planner

Skill(skill="planner")
→ Plan approved
→ Skill(skill="orchestration")
→ TeamCreate + parallel SendMessage
→ All tasks complete → wave merge

Task Tracking Commands

TaskList                              # All tasks + status
TaskUpdate <id> status=done           # Mark task complete
plan-db.sh validate-task <id> <plan>  # Thor per-task gate
plan-db.sh validate-wave <wave_id>    # Thor per-wave gate
wave-worktree.sh merge <plan> <wave>  # Merge on all done

Agent: agents/strategic-planner.md
Coordination patterns: agents/core_utility/xavier-coordination-patterns.md
ADR: docs/adr/0020-ecosystem-modernization-v2.1.md
Disabled predecessor: skills/.disabled/orchestration-kitty/SKILL.md

Source

git clone https://github.com/Roberdan/MyConvergio/blob/master/.claude/skills/orchestration/SKILL.mdView on GitHub

Overview

Orchestration coordinates a team of agents to tackle large, multi-subtask plans. It creates a named team, generates per-subtask tasks, assigns work, and tracks progress with TaskList and TaskUpdate, finishing with a shutdown protocol. This approach is ideal for complex tasks, multi-step releases, and big refactors across domains, especially plans created by strategic-planner.

How This Skill Works

Technically, you create a team with TeamCreate, then for each subtask you issue TaskCreate specifying title, description, and assignee. Work is dispatched with SendMessage to each member; progress is monitored via TaskList and status updated with TaskUpdate. When complete (or abort), you issue shutdown_request messages to all members and optionally perform wave merges after all tasks finish.

When to Use It

Complex tasks with 4+ independent subtasks
Release preparations with multiple verification steps
Large refactoring across multiple file domains
Any plan created by strategic-planner agent
Cross-domain plans requiring parallel execution and coordinated validation

Quick Start

Step 1: TeamCreate: "plan-{id}-executors" with members [baccio, marco, luca, rex]
Step 2: TaskCreate for each subtask with title, description, and assignee
Step 3: SendMessage to each member with task context; monitor via TaskList and use plan-db.sh gates

Best Practices

NO FILE OVERLAP: Assign disjoint file sets per agent
WORKTREE MANDATORY: Each agent must use wave worktree (not main)
TDD per task: Each agent follows RED → GREEN workflow
Thor per task: plan-db.sh validate-task before marking done
Monitor progress with TaskList/TaskUpdate and validate waves with plan-db.sh validate-wave

Example Use Cases

Example Team Creation Pattern: TeamCreate: plan-{id}-executors with members [baccio, marco, luca, rex]; TaskCreate for T-01..T-04; SendMessage to each member with per-task context
Shutdown protocol: After completion, SendMessage: to baccio/marco/luca/rex → type: shutdown_request
Strategic-planner integration: Planner approves plan → Orchestration runs TeamCreate + parallel SendMessage → All tasks complete → wave merge
Task tracking workflow: Use TaskList to monitor, TaskUpdate to mark progress, and plan-db.sh validate-task/validate-wave as gates
Pattern selection in practice: 2-3 for Small team; 4-6 Swarm for multi-domain plans; 7+ Mega-swarm for Opus coordination + TeamCreate

Frequently Asked Questions

Add this skill to your agents