home / skills / ruvnet / ruflo / agent-coordination

agent-coordination skill

This skill helps spawn and coordinate multiple agents for complex tasks, improving multi-agent collaboration and task orchestration across swarms.

npx playbooks add skill ruvnet/ruflo --skill agent-coordination

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.0 KB

---
name: agent-coordination
description: >
  Agent spawning, lifecycle management, and coordination patterns. Manages 60+ agent types with specialized capabilities.
  Use when: spawning agents, coordinating multi-agent tasks, managing agent pools.
  Skip when: single-agent work, no coordination needed.
---

# Agent Coordination Skill

## Purpose
Spawn and coordinate agents for complex multi-agent tasks.

## Agent Types

### Core Development
`coder`, `reviewer`, `tester`, `planner`, `researcher`

### V3 Specialized
`security-architect`, `security-auditor`, `memory-specialist`, `performance-engineer`

### Swarm Coordination
`hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`, `collective-intelligence-coordinator`

### Consensus
`byzantine-coordinator`, `raft-manager`, `gossip-coordinator`, `consensus-builder`

### GitHub
`pr-manager`, `code-review-swarm`, `issue-tracker`, `release-manager`

### SPARC
`sparc-coord`, `sparc-coder`, `specification`, `pseudocode`, `architecture`, `refinement`

## Commands

### Spawn Agent
```bash
npx claude-flow agent spawn --type coder --name my-coder
```

### List Agents
```bash
npx claude-flow agent list --filter active
```

### Agent Status
```bash
npx claude-flow agent status --id agent-123
```

### Agent Metrics
```bash
npx claude-flow agent metrics --id agent-123
```

### Stop Agent
```bash
npx claude-flow agent stop --id agent-123
```

### Pool Management
```bash
npx claude-flow agent pool --size 5 --type coder
```

## Routing Codes

| Code | Task | Agents |
|------|------|--------|
| 1 | Bug Fix | coordinator, researcher, coder, tester |
| 3 | Feature | coordinator, architect, coder, tester, reviewer |
| 5 | Refactor | coordinator, architect, coder, reviewer |
| 7 | Performance | coordinator, perf-engineer, coder |
| 9 | Security | coordinator, security-architect, auditor |

## Best Practices
1. Use hierarchical topology for coordination
2. Keep agent count under 8 for tight coordination
3. Use specialized agents for specific tasks
4. Coordinate via memory, not direct communication

Overview

This skill manages spawning, lifecycle, and coordination patterns for large multi-agent systems. It supports 60+ specialized agent types and provides tools for pool management, status monitoring, and metrics. Use it to deploy coordinated swarms, enforce routing patterns, and operate persistent agent fleets reliably.

How this skill works

The skill exposes commands to spawn agents, list and inspect status, collect metrics, stop agents, and manage agent pools. Agents are organized by roles (core development, security, swarm coordinators, consensus managers, GitHub-focused workers, and SPARC specialists) and coordinated using topology patterns like hierarchical, mesh, and adaptive coordination. Routing codes map task types to agent ensembles so workflows spawn the right mix automatically.

When to use it

Launching multi-agent workflows that require role specialization (e.g., coder + reviewer + tester).
Coordinating long-running or distributed tasks across many agents.
Managing a pool of reusable agents to reduce cold-start cost.
Needing consensus or fault-tolerant coordination (Byzantine, Raft, gossip patterns).
Orchestrating cross-cutting responsibilities like security audits or performance tuning.

Best practices

Prefer hierarchical topology for clear command flow and reduced coordination overhead.
Keep tightly coordinated groups under ~8 agents to avoid communication complexity.
Assign specialized agent types for focused tasks (security-architect, performance-engineer, memory-specialist).
Use shared memory/state channels rather than direct peer-to-peer chatter for coordination.
Define routing codes for repeatable task-to-agent mappings (bug fix, feature, refactor, performance, security).

Example use cases

Spawn a coder + reviewer + tester ensemble to implement and validate a new feature using the feature routing code.
Create a pool of 5 coder agents to handle bursty code generation while reusing warm contexts.
Deploy a consensus-backed refactor workflow using Raft manager to ensure coordinated commits.
Run a security sweep with security-architect and security-auditor agents coordinated by a hierarchical coordinator.
Orchestrate a SPARC-driven specification and refinement loop combining spec, pseudocode, and architecture agents.

FAQ

How do I spawn an agent quickly?

Use the spawn command with type and name, for example: npx claude-flow agent spawn --type coder --name my-coder.

When should I use a pool instead of individual agents?

Use pools when you expect repeated or bursty tasks to reduce startup latency and reuse agent context; pools are ideal for homogeneous roles like coder fleets.

What coordination topologies are available?

Supported topologies include hierarchical, mesh, adaptive, and collective-intelligence coordinators; choose based on fault tolerance and command routing needs.