swarm-coordination

Context

• Task: [What was done]
• Files: [Files touched]

Findings

• [Key finding 1]
• [Key finding 2]

Recommendations

• [Action item 1]
• [Action item 2]

Artifacts

• [Path to artifact 1]
• [Path to artifact 2]

```

Step 4: Aggregate Results

Combine outputs from parallel agents:

```markdown

Participating Agents

• Architect: Completed ✅
• Security: Completed ✅
• DevOps: Completed ✅

Consensus Points

• [Point all agents agree on]

Conflicts

• [Point agents disagree on]
• Resolution: [How to resolve]

Combined Recommendations

1. [Prioritized recommendation]
2. [Prioritized recommendation]

```

Step 5: Handle Failures

Strategies for partial failures:

| Scenario | Strategy |

| ----------------------- | ------------------------------- |

| Agent timeout | Retry with simpler prompt |

| Agent error | Continue with available results |

| Conflicting results | Use consensus-voting skill |

| Missing critical result | Block and retry |

1. Parallelize Aggressively: Independent work should run in parallel
2. Structured Handoffs: Use consistent formats for communication
3. Graceful Degradation: Continue with partial results when safe
4. Clear Aggregation: Combine results systematically
5. Track Provenance: Know which agent produced each result

Parallel Review Request:

```

Get architecture, security, and performance reviews for the new API design

```

Swarm Coordination:

```javascript

// Spawn 3 reviewers in parallel (single message)

Task({ description: 'Architect reviewing API', prompt: '...' });

Task({ description: 'Security reviewing API', prompt: '...' });

Task({ description: 'Performance reviewing API', prompt: '...' });

```

Aggregated Results:

```markdown

Consensus

• RESTful design is appropriate
• Need authentication on all endpoints

Recommendations by Priority

1. [HIGH] Add rate limiting (Security)
2. [HIGH] Use connection pooling (Performance)
3. [MED] Add versioning to URLs (Architect)

```

• Always spawn independent agents in parallel
• Use structured handoff formats
• Handle partial failures gracefully

This skill has a corresponding workflow for complex multi-agent scenarios:

• Workflow: .claude/workflows/enterprise/swarm-coordination-skill-workflow.md
• When to use workflow: For massively parallel task execution with Queen/Worker topology, fault tolerance, and distributed coordination (large-scale refactoring, parallel code review, multi-file implementation)
• When to use skill directly: For simple parallel agent spawning or when integrating swarm patterns into other workflows

This skill powers multi-agent orchestration patterns across the framework:

Router Decision: .claude/workflows/core/router-decision.md

• Router uses swarm patterns for parallel agent spawning
• Planning Orchestration Matrix defines when to use swarm coordination

Artifact Lifecycle: .claude/workflows/core/skill-lifecycle.md

• Swarm patterns apply to artifact creation at scale
• Parallel validation of multiple artifacts

Related Workflows:

• consensus-voting skill for resolving conflicting agent outputs
• context-compressor skill for aggregating parallel results
• Enterprise workflows in .claude/workflows/enterprise/ use swarm patterns

---

Before starting:

```bash

cat .claude/context/memory/learnings.md

```

After completing:

• New pattern -> .claude/context/memory/learnings.md
• Issue found -> .claude/context/memory/issues.md
• Decision made -> .claude/context/memory/decisions.md

> ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.