swarm-coordination
Multi-agent swarm coordination patterns. Orchestrates parallel agent execution, manages agent communication, handles task distribution, and coordinates results aggregation.
How do I install this agent skill?
npx skills add https://github.com/oimiragieo/agent-studio --skill swarm-coordinationIs this agent skill safe to install?
- Gen Agent Trust Hubpass
The swarm-coordination skill provides a framework for orchestrating multiple AI agents in parallel workflows. It defines patterns for task distribution, results aggregation, and inter-agent communication using standard agent capabilities. No malicious patterns, obfuscation, or unauthorized data access were detected.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
- Runlayerpass
3/10 files flagged
What does this agent skill do?
Swarm Coordination Skill
<identity> Swarm Coordination Skill - Orchestrates parallel agent execution, manages inter-agent communication, handles task distribution, and coordinates results aggregation for complex multi-agent workflows. </identity> <capabilities> - Parallel agent spawning - Task distribution strategies - Results aggregation - Inter-agent communication - Failure handling and recovery </capabilities> <instructions> <execution_process>Step 1: Analyze Task for Parallelization
Identify parallelizable work:
| Pattern | Example | Strategy |
|---|---|---|
| Independent tasks | Review multiple files | Spawn in parallel |
| Dependent tasks | Design → Implement | Sequential spawn |
| Fan-out/Fan-in | Multiple reviews → Consolidate | Parallel + Aggregation |
| Pipeline | Parse → Transform → Validate | Sequential handoff |
Step 2: Spawn Agents in Parallel
Use the Task tool to spawn multiple agents in a single message:
// Spawn multiple agents in ONE message for parallel execution
Task({
task_id: 'task-1',
subagent_type: 'general-purpose',
description: 'Architect reviewing design',
prompt: 'Review architecture...',
});
Task({
task_id: 'task-2',
subagent_type: 'general-purpose',
description: 'Security reviewing design',
prompt: 'Review security...',
});
Key: Both Task calls must be in the SAME message for true parallelism.
Step 3: Define Handoff Format
Use structured formats for agent communication:
## Agent Handoff: [Source] → [Target]
### 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:
## Swarm Results Aggregation
### 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 |
</execution_process>
<best_practices>
- Parallelize Aggressively: Independent work should run in parallel
- Structured Handoffs: Use consistent formats for communication
- Graceful Degradation: Continue with partial results when safe
- Clear Aggregation: Combine results systematically
- Track Provenance: Know which agent produced each result
</best_practices> </instructions>
<examples> <usage_example> **Parallel Review Request**:Get architecture, security, and performance reviews for the new API design
Swarm Coordination:
// Spawn 3 reviewers in parallel (single message)
Task({ task_id: 'task-3', description: 'Architect reviewing API', prompt: '...' });
Task({ task_id: 'task-4', description: 'Security reviewing API', prompt: '...' });
Task({ task_id: 'task-5', description: 'Performance reviewing API', prompt: '...' });
Aggregated Results:
## API Design Review (3 agents)
### 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)
</usage_example> </examples>
Rules
- Always spawn independent agents in parallel
- Use structured handoff formats
- Handle partial failures gracefully
Related Workflow
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
Workflow Integration
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-votingskill for resolving conflicting agent outputscontext-compressorskill for aggregating parallel results- Enterprise workflows in
.claude/workflows/enterprise/use swarm patterns
Iron Laws
- NEVER spawn workers sequentially — all independent agents must be dispatched in a single message
- ALWAYS implement failure detection; never let a hung worker block the swarm indefinitely
- NEVER allow cross-worker communication — all coordination must flow through the Queen
- ALWAYS use structured handoff format for worker reports to enable programmatic aggregation
- NEVER spawn more than 7 workers in a single fan-out — coordination overhead dominates beyond that
Anti-Patterns
| Anti-Pattern | Why It Fails | Correct Approach |
|---|---|---|
| Sequential spawning | No parallelism; swarm executes like a queue | Spawn all independent workers in a single message |
| Cross-worker communication | O(N²) coordination chaos | All worker-to-worker communication flows through the Queen |
| No failure handling | One worker crash stalls the swarm | Detect hung/failed workers and re-spawn with fresh state |
| Unbounded parallelism | Coordination overhead exceeds speedup beyond 7 workers | Limit to 5-7 workers per fan-out for optimal throughput |
| Free-form worker reports | Cannot aggregate results programmatically | Require all workers to use the structured handoff template |
Memory Protocol (MANDATORY)
Before starting:
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.
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/oimiragieo/agent-studio/swarm-coordination">View swarm-coordination on skillZs</a>