// Multi-agent coordination, orchestrator-worker patterns, /plan decomposition, and project coordination for GitHub Agentic Workflows
| name | agentic-workflow-orchestration |
| description | Multi-agent coordination, orchestrator-worker patterns, /plan decomposition, and project coordination for GitHub Agentic Workflows |
| license | Apache-2.0 |
Guidance on orchestrating multiple agentic workflows for complex problems through coordination, delegation, and parallel execution. Includes proven patterns from the Agent Factory (100+ workflows, 500+ merged PRs) including /plan decomposition, task mining, and stacked agent coordination.
Apply this skill when:
/plan command for issue decompositionMUST:
MUST NOT:
MUST:
MUST NOT:
MUST:
MUST NOT:
MUST:
workflow_dispatch with inputs for orchestrator→worker communicationMUST NOT:
MUST:
MUST NOT:
MUST:
MUST NOT:
Structure:
Use Cases:
Structure:
Use Cases:
Structure:
Use Cases:
Structure:
Use Cases:
Structure:
Use Cases:
Structure:
Use Cases:
Orchestrator (daily-orchestrator.md):
---
on: daily
permissions: read-all
tools:
github:
safe-outputs:
create-issue:
max: 1
---
# Daily Repository Orchestrator
Coordinate daily analysis across all open issues:
1. List all open issues in repository
2. For each issue, dispatch `issue-analyzer` worker workflow with issue number
3. Wait for all workers to complete (check workflow run statuses)
4. Collect results from worker comments
5. Generate summary report issue titled "Daily Analysis Report - [DATE]"
Include:
- Total issues analyzed
- Critical issues found
- Recommendations summary
- Links to worker analysis comments
Worker (issue-analyzer.md):
---
on:
workflow_dispatch:
inputs:
issue_number:
required: true
type: number
permissions: read-all
tools:
github:
safe-outputs:
create-comment:
max: 1
---
# Issue Analyzer Worker
Analyze issue #${{ inputs.issue_number }}:
1. Read issue title, body, labels, and comments
2. Check for duplicates
3. Assess clarity and completeness
4. Identify missing information
5. Suggest appropriate labels
Post analysis as comment on the issue.
Use structured format:
- Status: [Clear/Unclear/Duplicate]
- Suggested Labels: [label1, label2]
- Action: [what should happen next]
Top-Level Orchestrator (repo-health-orchestrator.md):
---
on: weekly on monday
permissions: read-all
tools:
github:
safe-outputs:
create-issue:
max: 1
---
# Repository Health Orchestrator
Coordinate comprehensive repository health check:
Phase 1: Dispatch specialized orchestrators
1. Dispatch `issue-health-orchestrator`
2. Dispatch `pr-health-orchestrator`
3. Dispatch `code-health-orchestrator`
Phase 2: Wait and collect
1. Wait for all phase 1 orchestrators to complete
2. Collect results from each orchestrator issue
Phase 3: Synthesize
1. Combine results into master health report
2. Generate action items by priority
3. Create issue with complete repository health status
Mid-Level Orchestrator (issue-health-orchestrator.md):
---
on:
workflow_dispatch:
permissions: read-all
tools:
github:
safe-outputs:
create-issue:
max: 1
---
# Issue Health Orchestrator
Coordinate issue-specific analysis:
1. Dispatch workers for:
- Stale issue detection
- Issue categorization
- Response time analysis
- Label consistency check
2. Collect worker results
3. Generate issue health report
4. Create issue with findings
Pipeline Orchestrator (deployment-pipeline.md):
---
on: workflow_dispatch
permissions: read-all
tools:
github:
safe-outputs:
create-comment:
max: 5
---
# Deployment Pipeline Orchestrator
Coordinate deployment pipeline stages:
Stage 1: Validation
1. Dispatch `security-validator` worker
2. Dispatch `test-validator` worker
3. Wait for both, check results
4. If any failures, stop and report
Stage 2: Staging Deployment
1. Dispatch `staging-deployer` worker
2. Wait for completion
3. Dispatch `staging-validator` worker
4. If validation fails, rollback and stop
Stage 3: Production Deployment
1. Require manual approval (create approval issue)
2. After approval, dispatch `production-deployer` worker
3. Dispatch `production-validator` worker
4. Generate deployment report
Post progress comments at each stage.
Router (issue-router.md):
---
on: issues
permissions: read-all
tools:
github:
---
# Issue Router
Route new issues to specialized handlers:
1. Analyze issue labels and content
2. Determine issue type:
- Bug → dispatch `bug-triage-worker`
- Feature Request → dispatch `feature-triage-worker`
- Security → dispatch `security-triage-worker`
- Documentation → dispatch `docs-triage-worker`
- General → dispatch `general-triage-worker`
3. Dispatch appropriate worker with issue number
4. Post comment indicating routing decision
Map-Reduce Orchestrator (security-audit-orchestrator.md):
---
on: workflow_dispatch
permissions: read-all
tools:
github:
safe-outputs:
create-issue:
max: 1
create-code-scanning-alert:
max: 1
---
# Security Audit Orchestrator (Map-Reduce)
Coordinate security audit across entire codebase:
MAP PHASE:
1. List all repositories in organization
2. For each repository, dispatch `security-scanner` worker
3. Track dispatched workers
REDUCE PHASE:
1. Wait for all scanners to complete
2. Collect SARIF reports from each worker
3. Aggregate findings:
- Total vulnerabilities by severity
- Top vulnerability types
- Repositories with most issues
4. Generate consolidated SARIF report
5. Create master security issue with summary
Reflection Orchestrator (doc-generator-orchestrator.md):
---
on: workflow_dispatch
permissions: read-all
tools:
github:
safe-outputs:
create-pull-request:
max: 1
---
# Documentation Generator with Reflection
Use reflection pattern for high-quality docs:
Iteration Loop (max 3 iterations):
1. Dispatch `doc-generator` worker to create documentation
2. Dispatch `doc-critic` worker to review generated docs
3. Collect critique feedback
4. If quality score >= 8/10, proceed to next step
5. If quality score < 8/10, regenerate with critique feedback
Final Step:
1. Create pull request with approved documentation
2. Include quality metrics in PR description
3. Link to critic reviews
Orchestrator with Circuit Breaker (resilient-orchestrator.md):
---
on: schedule
permissions: read-all
tools:
github:
safe-outputs:
create-issue:
max: 1
---
# Resilient Orchestrator with Circuit Breaker
Coordinate workers with failure protection:
For each task in task_list:
1. Check circuit breaker state for worker type
2. If OPEN (too many recent failures), skip and log
3. If CLOSED, dispatch worker
4. Track worker success/failure
5. Update circuit breaker state:
- 3 consecutive failures → OPEN circuit
- 1 success after OPEN → HALF-OPEN
- 3 successes in HALF-OPEN → CLOSED
Generate report with:
- Tasks completed successfully
- Tasks skipped (circuit open)
- Circuit breaker states
- Recommended actions
Dynamic Pool Orchestrator (scalable-orchestrator.md):
---
on: workflow_dispatch
permissions: read-all
tools:
github:
safe-outputs:
create-issue:
max: 1
---
# Dynamic Worker Pool Orchestrator
Scale workers based on workload:
1. Assess workload size (e.g., count of items to process)
2. Calculate optimal worker count (workload / items_per_worker)
3. Respect concurrency limits (max 10 concurrent workers)
4. Batch items for each worker
5. Dispatch workers with batch assignments
6. Monitor worker progress
7. If workers fail, redistribute work to new workers
8. Aggregate results when all batches complete
9. Generate completion report with metrics:
- Items processed
- Workers used
- Success rate
- Processing time
This skill aligns with:
Orchestration pattern violations:
GitHub Agentic Workflows (gh-aw) - markdown-based AI automation with 5-layer security, safe outputs, and Continuous AI patterns
gh-aw CLI usage, compilation, testing, debugging, add-wizard, and CI/CD practices for GitHub Agentic Workflows
5-layer defense-in-depth security for GitHub Agentic Workflows - safe outputs, threat detection, AWF firewall, and zero-trust patterns
Continuous AI patterns from Agent Factory - issue triage, documentation sync, code quality, security scanning, and project coordination
GDPR compliance including privacy by design, data protection requirements, consent management, right to be forgotten, and data breach response
Approved cryptographic algorithms, TLS enforcement, key management, and certificate handling per Hack23 Cryptographic Controls Policy