---
name: swarm-advanced
description: Advanced swarm orchestration patterns for research, development, testing, and complex distributed workflows
version: 2.0.0
category: orchestration
tags: [swarm, distributed, parallel, research, testing, development, coordination]
author: Claude Flow Team
---

# Advanced Swarm Orchestration

Master advanced swarm patterns for distributed research, development, and testing workflows. This skill covers comprehensive orchestration strategies using both MCP tools and CLI commands.

## Quick Start

### Prerequisites

```bash
# Ensure Claude Flow is installed
npm install -g claude-flow@alpha

# Add MCP server (if using MCP tools)
claude mcp add claude-flow npx claude-flow@alpha mcp start
```

### Basic Pattern

```javascript
// 1. Initialize swarm topology
mcp__claude - flow__swarm_init({ topology: "mesh", maxAgents: 6 });

// 2. Spawn specialized agents
mcp__claude - flow__agent_spawn({ type: "researcher", name: "Agent 1" });

// 3. Orchestrate tasks
mcp__claude - flow__task_orchestrate({ task: "...", strategy: "parallel" });
```

## Core Concepts

### Swarm Topologies

**Mesh Topology** - Peer-to-peer communication, best for research and analysis

- All agents communicate directly
- High flexibility and resilience
- Use for: Research, analysis, brainstorming

**Hierarchical Topology** - Coordinator with subordinates, best for development

- Clear command structure
- Sequential workflow support
- Use for: Development, structured workflows

**Star Topology** - Central coordinator, best for testing

- Centralized control and monitoring
- Parallel execution with coordination
- Use for: Testing, validation, quality assurance

**Ring Topology** - Sequential processing chain

- Step-by-step processing
- Pipeline workflows
- Use for: Multi-stage processing, data pipelines

### Agent Strategies

**Adaptive** - Dynamic adjustment based on task complexity
**Balanced** - Equal distribution of work across agents
**Specialized** - Task-specific agent assignment
**Parallel** - Maximum concurrent execution

## Pattern 1: Research Swarm

### Purpose

Deep research through parallel information gathering, analysis, and synthesis.

### Architecture

```javascript
// Initialize research swarm
mcp__claude -
  flow__swarm_init({
    topology: "mesh",
    maxAgents: 6,
    strategy: "adaptive",
  });

// Spawn research team
const researchAgents = [
  {
    type: "researcher",
    name: "Web Researcher",
    capabilities: ["web-search", "content-extraction", "source-validation"],
  },
  {
    type: "researcher",
    name: "Academic Researcher",
    capabilities: ["paper-analysis", "citation-tracking", "literature-review"],
  },
  {
    type: "analyst",
    name: "Data Analyst",
    capabilities: ["data-processing", "statistical-analysis", "visualization"],
  },
  {
    type: "analyst",
    name: "Pattern Analyzer",
    capabilities: ["trend-detection", "correlation-analysis", "outlier-detection"],
  },
  {
    type: "documenter",
    name: "Report Writer",
    capabilities: ["synthesis", "technical-writing", "formatting"],
  },
];

// Spawn all agents
researchAgents.forEach((agent) => {
  mcp__claude -
    flow__agent_spawn({
      type: agent.type,
      name: agent.name,
      capabilities: agent.capabilities,
    });
});
```

### Research Workflow

#### Phase 1: Information Gathering

```javascript
// Parallel information collection
mcp__claude -
  flow__parallel_execute({
    tasks: [
      {
        id: "web-search",
        command: "search recent publications and articles",
      },
      {
        id: "academic-search",
        command: "search academic databases and papers",
      },
      {
        id: "data-collection",
        command: "gather relevant datasets and statistics",
      },
      {
        id: "expert-search",
        command: "identify domain experts and thought leaders",
      },
    ],
  });

// Store research findings in memory
mcp__claude -
  flow__memory_usage({
    action: "store",
    key: "research-findings-" + Date.now(),
    value: JSON.stringify(findings),
    namespace: "research",
    ttl: 604800, // 7 days
  });
```

#### Phase 2: Analysis and Validation

```javascript
// Pattern recognition in findings
mcp__claude -
  flow__pattern_recognize({
    data: researchData,
    patterns: ["trend", "correlation", "outlier", "emerging-pattern"],
  });

// Cognitive analysis
mcp__claude -
  flow__cognitive_analyze({
    behavior: "research-synthesis",
  });

// Quality assessment
mcp__claude -
  flow__quality_assess({
    target: "research-sources",
    criteria: ["credibility", "relevance", "recency", "authority"],
  });

// Cross-reference validation
mcp__claude -
  flow__neural_patterns({
    action: "analyze",
    operation: "fact-checking",
    metadata: { sources: sourcesArray },
  });
```

#### Phase 3: Knowledge Management

```javascript
// Search existing knowledge base
mcp__claude -
  flow__memory_search({
    pattern: "topic X",
    namespace: "research",
    limit: 20,
  });

// Create knowledge graph connections
mcp__claude -
  flow__neural_patterns({
    action: "learn",
    operation: "knowledge-graph",
    metadata: {
      topic: "X",
      connections: relatedTopics,
      depth: 3,
    },
  });

// Store connections for future use
mcp__claude -
  flow__memory_usage({
    action: "store",
    key: "knowledge-graph-X",
    value: JSON.stringify(knowledgeGraph),
    namespace: "research/graphs",
    ttl: 2592000, // 30 days
  });
```

#### Phase 4: Report Generation

```javascript
// Orchestrate report generation
mcp__claude -
  flow__task_orchestrate({
    task: "generate comprehensive research report",
    strategy: "sequential",
    priority: "high",
    dependencies: ["gather", "analyze", "validate", "synthesize"],
  });

// Monitor research progress
mcp__claude -
  flow__swarm_status({
    swarmId: "research-swarm",
  });

// Generate final report
mcp__claude -
  flow__workflow_execute({
    workflowId: "research-report-generation",
    params: {
      findings: findings,
      format: "comprehensive",
      sections: [
        "executive-summary",
        "methodology",
        "findings",
        "analysis",
        "conclusions",
        "references",
      ],
    },
  });
```

### CLI Fallback

```bash
# Quick research swarm
npx claude-flow swarm "research AI trends in 2025" \
  --strategy research \
  --mode distributed \
  --max-agents 6 \
  --parallel \
  --output research-report.md
```

## Pattern 2: Development Swarm

### Purpose

Full-stack development through coordinated specialist agents.

### Architecture

```javascript
// Initialize development swarm with hierarchy
mcp__claude -
  flow__swarm_init({
    topology: "hierarchical",
    maxAgents: 8,
    strategy: "balanced",
  });

// Spawn development team
const devTeam = [
  { type: "architect", name: "System Architect", role: "coordinator" },
  { type: "coder", name: "Backend Developer", capabilities: ["node", "api", "database"] },
  { type: "coder", name: "Frontend Developer", capabilities: ["react", "ui", "ux"] },
  { type: "coder", name: "Database Engineer", capabilities: ["sql", "nosql", "optimization"] },
  { type: "tester", name: "QA Engineer", capabilities: ["unit", "integration", "e2e"] },
  {
    type: "reviewer",
    name: "Code Reviewer",
    capabilities: ["security", "performance", "best-practices"],
  },
  {
    type: "documenter",
    name: "Technical Writer",
    capabilities: ["api-docs", "guides", "tutorials"],
  },
  { type: "monitor", name: "DevOps Engineer", capabilities: ["ci-cd", "deployment", "monitoring"] },
];

// Spawn all team members
devTeam.forEach((member) => {
  mcp__claude -
    flow__agent_spawn({
      type: member.type,
      name: member.name,
      capabilities: member.capabilities,
      swarmId: "dev-swarm",
    });
});
```

### Development Workflow

#### Phase 1: Architecture and Design

```javascript
// System architecture design
mcp__claude -
  flow__task_orchestrate({
    task: "design system architecture for REST API",
    strategy: "sequential",
    priority: "critical",
    assignTo: "System Architect",
  });

// Store architecture decisions
mcp__claude -
  flow__memory_usage({
    action: "store",
    key: "architecture-decisions",
    value: JSON.stringify(architectureDoc),
    namespace: "development/design",
  });
```

#### Phase 2: Parallel Implementation

```javascript
// Parallel development tasks
mcp__claude -
  flow__parallel_execute({
    tasks: [
      {
        id: "backend-api",
        command: "implement REST API endpoints",
        assignTo: "Backend Developer",
      },
      {
        id: "frontend-ui",
        command: "build user interface components",
        assignTo: "Frontend Developer",
      },
      {
        id: "database-schema",
        command: "design and implement database schema",
        assignTo: "Database Engineer",
      },
      {
        id: "api-documentation",
        command: "create API documentation",
        assignTo: "Technical Writer",
      },
    ],
  });

// Monitor development progress
mcp__claude -
  flow__swarm_monitor({
    swarmId: "dev-swarm",
    interval: 5000,
  });
```

#### Phase 3: Testing and Validation

```javascript
// Comprehensive testing
mcp__claude -
  flow__batch_process({
    items: [
      { type: "unit", target: "all-modules" },
      { type: "integration", target: "api-endpoints" },
      { type: "e2e", target: "user-flows" },
      { type: "performance", target: "critical-paths" },
    ],
    operation: "execute-tests",
  });

// Quality assessment
mcp__claude -
  flow__quality_assess({
    target: "codebase",
    criteria: ["coverage", "complexity", "maintainability", "security"],
  });
```

#### Phase 4: Review and Deployment

```javascript
// Code review workflow
mcp__claude -
  flow__workflow_execute({
    workflowId: "code-review-process",
    params: {
      reviewers: ["Code Reviewer"],
      criteria: ["security", "performance", "best-practices"],
    },
  });

// CI/CD pipeline
mcp__claude -
  flow__pipeline_create({
    config: {
      stages: ["build", "test", "security-scan", "deploy"],
      environment: "production",
    },
  });
```

### CLI Fallback

```bash
# Quick development swarm
npx claude-flow swarm "build REST API with authentication" \
  --strategy development \
  --mode hierarchical \
  --monitor \
  --output sqlite
```

## Pattern 3: Testing Swarm

### Purpose

Comprehensive quality assurance through distributed testing.

### Architecture

```javascript
// Initialize testing swarm with star topology
mcp__claude -
  flow__swarm_init({
    topology: "star",
    maxAgents: 7,
    strategy: "parallel",
  });

// Spawn testing team
const testingTeam = [
  {
    type: "tester",
    name: "Unit Test Coordinator",
    capabilities: ["unit-testing", "mocking", "coverage", "tdd"],
  },
  {
    type: "tester",
    name: "Integration Tester",
    capabilities: ["integration", "api-testing", "contract-testing"],
  },
  {
    type: "tester",
    name: "E2E Tester",
    capabilities: ["e2e", "ui-testing", "user-flows", "selenium"],
  },
  {
    type: "tester",
    name: "Performance Tester",
    capabilities: ["load-testing", "stress-testing", "benchmarking"],
  },
  {
    type: "monitor",
    name: "Security Tester",
    capabilities: ["security-testing", "penetration-testing", "vulnerability-scanning"],
  },
  {
    type: "analyst",
    name: "Test Analyst",
    capabilities: ["coverage-analysis", "test-optimization", "reporting"],
  },
  {
    type: "documenter",
    name: "Test Documenter",
    capabilities: ["test-documentation", "test-plans", "reports"],
  },
];

// Spawn all testers
testingTeam.forEach((tester) => {
  mcp__claude -
    flow__agent_spawn({
      type: tester.type,
      name: tester.name,
      capabilities: tester.capabilities,
      swarmId: "testing-swarm",
    });
});
```

### Testing Workflow

#### Phase 1: Test Planning

```javascript
// Analyze test coverage requirements
mcp__claude -
  flow__quality_assess({
    target: "test-coverage",
    criteria: ["line-coverage", "branch-coverage", "function-coverage", "edge-cases"],
  });

// Identify test scenarios
mcp__claude -
  flow__pattern_recognize({
    data: testScenarios,
    patterns: ["edge-case", "boundary-condition", "error-path", "happy-path"],
  });

// Store test plan
mcp__claude -
  flow__memory_usage({
    action: "store",
    key: "test-plan-" + Date.now(),
    value: JSON.stringify(testPlan),
    namespace: "testing/plans",
  });
```

#### Phase 2: Parallel Test Execution

```javascript
// Execute all test suites in parallel
mcp__claude -
  flow__parallel_execute({
    tasks: [
      {
        id: "unit-tests",
        command: "npm run test:unit",
        assignTo: "Unit Test Coordinator",
      },
      {
        id: "integration-tests",
        command: "npm run test:integration",
        assignTo: "Integration Tester",
      },
      {
        id: "e2e-tests",
        command: "npm run test:e2e",
        assignTo: "E2E Tester",
      },
      {
        id: "performance-tests",
        command: "npm run test:performance",
        assignTo: "Performance Tester",
      },
      {
        id: "security-tests",
        command: "npm run test:security",
        assignTo: "Security Tester",
      },
    ],
  });

// Batch process test suites
mcp__claude -
  flow__batch_process({
    items: testSuites,
    operation: "execute-test-suite",
  });
```

#### Phase 3: Performance and Security

```javascript
// Run performance benchmarks
mcp__claude -
  flow__benchmark_run({
    suite: "comprehensive-performance",
  });

// Bottleneck analysis
mcp__claude -
  flow__bottleneck_analyze({
    component: "application",
    metrics: ["response-time", "throughput", "memory", "cpu"],
  });

// Security scanning
mcp__claude -
  flow__security_scan({
    target: "application",
    depth: "comprehensive",
  });

// Vulnerability analysis
mcp__claude -
  flow__error_analysis({
    logs: securityScanLogs,
  });
```

#### Phase 4: Monitoring and Reporting

```javascript
// Real-time test monitoring
mcp__claude -
  flow__swarm_monitor({
    swarmId: "testing-swarm",
    interval: 2000,
  });

// Generate comprehensive test report
mcp__claude -
  flow__performance_report({
    format: "detailed",
    timeframe: "current-run",
  });

// Get test results
mcp__claude -
  flow__task_results({
    taskId: "test-execution-001",
  });

// Trend analysis
mcp__claude -
  flow__trend_analysis({
    metric: "test-coverage",
    period: "30d",
  });
```

### CLI Fallback

```bash
# Quick testing swarm
npx claude-flow swarm "test application comprehensively" \
  --strategy testing \
  --mode star \
  --parallel \
  --timeout 600
```

## Pattern 4: Analysis Swarm

### Purpose

Deep code and system analysis through specialized analyzers.

### Architecture

```javascript
// Initialize analysis swarm
mcp__claude -
  flow__swarm_init({
    topology: "mesh",
    maxAgents: 5,
    strategy: "adaptive",
  });

// Spawn analysis specialists
const analysisTeam = [
  {
    type: "analyst",
    name: "Code Analyzer",
    capabilities: ["static-analysis", "complexity-analysis", "dead-code-detection"],
  },
  {
    type: "analyst",
    name: "Security Analyzer",
    capabilities: ["security-scan", "vulnerability-detection", "dependency-audit"],
  },
  {
    type: "analyst",
    name: "Performance Analyzer",
    capabilities: ["profiling", "bottleneck-detection", "optimization"],
  },
  {
    type: "analyst",
    name: "Architecture Analyzer",
    capabilities: ["dependency-analysis", "coupling-detection", "modularity-assessment"],
  },
  {
    type: "documenter",
    name: "Analysis Reporter",
    capabilities: ["reporting", "visualization", "recommendations"],
  },
];

// Spawn all analysts
analysisTeam.forEach((analyst) => {
  mcp__claude -
    flow__agent_spawn({
      type: analyst.type,
      name: analyst.name,
      capabilities: analyst.capabilities,
    });
});
```

### Analysis Workflow

```javascript
// Parallel analysis execution
mcp__claude -
  flow__parallel_execute({
    tasks: [
      { id: "analyze-code", command: "analyze codebase structure and quality" },
      { id: "analyze-security", command: "scan for security vulnerabilities" },
      { id: "analyze-performance", command: "identify performance bottlenecks" },
      { id: "analyze-architecture", command: "assess architectural patterns" },
    ],
  });

// Generate comprehensive analysis report
mcp__claude -
  flow__performance_report({
    format: "detailed",
    timeframe: "current",
  });

// Cost analysis
mcp__claude -
  flow__cost_analysis({
    timeframe: "30d",
  });
```

## Advanced Techniques

### Error Handling and Fault Tolerance

```javascript
// Setup fault tolerance for all agents
mcp__claude -
  flow__daa_fault_tolerance({
    agentId: "all",
    strategy: "auto-recovery",
  });

// Error handling pattern
try {
  (await mcp__claude) -
    flow__task_orchestrate({
      task: "complex operation",
      strategy: "parallel",
      priority: "high",
    });
} catch (error) {
  // Check swarm health
  const status = (await mcp__claude) - flow__swarm_status({});

  // Analyze error patterns
  (await mcp__claude) -
    flow__error_analysis({
      logs: [error.message],
    });

  // Auto-recovery attempt
  if (status.healthy) {
    (await mcp__claude) -
      flow__task_orchestrate({
        task: "retry failed operation",
        strategy: "sequential",
      });
  }
}
```

### Memory and State Management

```javascript
// Cross-session persistence
mcp__claude -
  flow__memory_persist({
    sessionId: "swarm-session-001",
  });

// Namespace management for different swarms
mcp__claude -
  flow__memory_namespace({
    namespace: "research-swarm",
    action: "create",
  });

// Create state snapshot
mcp__claude -
  flow__state_snapshot({
    name: "development-checkpoint-1",
  });

// Restore from snapshot if needed
mcp__claude -
  flow__context_restore({
    snapshotId: "development-checkpoint-1",
  });

// Backup memory stores
mcp__claude -
  flow__memory_backup({
    path: "/workspaces/claude-code-flow/backups/swarm-memory.json",
  });
```

### Neural Pattern Learning

```javascript
// Train neural patterns from successful workflows
mcp__claude -
  flow__neural_train({
    pattern_type: "coordination",
    training_data: JSON.stringify(successfulWorkflows),
    epochs: 50,
  });

// Adaptive learning from experience
mcp__claude -
  flow__learning_adapt({
    experience: {
      workflow: "research-to-report",
      success: true,
      duration: 3600,
      quality: 0.95,
    },
  });

// Pattern recognition for optimization
mcp__claude -
  flow__pattern_recognize({
    data: workflowMetrics,
    patterns: ["bottleneck", "optimization-opportunity", "efficiency-gain"],
  });
```

### Workflow Automation

```javascript
// Create reusable workflow
mcp__claude -
  flow__workflow_create({
    name: "full-stack-development",
    steps: [
      { phase: "design", agents: ["architect"] },
      { phase: "implement", agents: ["backend-dev", "frontend-dev"], parallel: true },
      { phase: "test", agents: ["tester", "security-tester"], parallel: true },
      { phase: "review", agents: ["reviewer"] },
      { phase: "deploy", agents: ["devops"] },
    ],
    triggers: ["on-commit", "scheduled-daily"],
  });

// Setup automation rules
mcp__claude -
  flow__automation_setup({
    rules: [
      {
        trigger: "file-changed",
        pattern: "*.js",
        action: "run-tests",
      },
      {
        trigger: "PR-created",
        action: "code-review-swarm",
      },
    ],
  });

// Event-driven triggers
mcp__claude -
  flow__trigger_setup({
    events: ["code-commit", "PR-merge", "deployment"],
    actions: ["test", "analyze", "document"],
  });
```

### Performance Optimization

```javascript
// Topology optimization
mcp__claude -
  flow__topology_optimize({
    swarmId: "current-swarm",
  });

// Load balancing
mcp__claude -
  flow__load_balance({
    swarmId: "development-swarm",
    tasks: taskQueue,
  });

// Agent coordination sync
mcp__claude -
  flow__coordination_sync({
    swarmId: "development-swarm",
  });

// Auto-scaling
mcp__claude -
  flow__swarm_scale({
    swarmId: "development-swarm",
    targetSize: 12,
  });
```

### Monitoring and Metrics

```javascript
// Real-time swarm monitoring
mcp__claude -
  flow__swarm_monitor({
    swarmId: "active-swarm",
    interval: 3000,
  });

// Collect comprehensive metrics
mcp__claude -
  flow__metrics_collect({
    components: ["agents", "tasks", "memory", "performance"],
  });

// Health monitoring
mcp__claude -
  flow__health_check({
    components: ["swarm", "agents", "neural", "memory"],
  });

// Usage statistics
mcp__claude -
  flow__usage_stats({
    component: "swarm-orchestration",
  });

// Trend analysis
mcp__claude -
  flow__trend_analysis({
    metric: "agent-performance",
    period: "7d",
  });
```

## Best Practices

### 1. Choosing the Right Topology

- **Mesh**: Research, brainstorming, collaborative analysis
- **Hierarchical**: Structured development, sequential workflows
- **Star**: Testing, validation, centralized coordination
- **Ring**: Pipeline processing, staged workflows

### 2. Agent Specialization

- Assign specific capabilities to each agent
- Avoid overlapping responsibilities
- Use coordination agents for complex workflows
- Leverage memory for agent communication

### 3. Parallel Execution

- Identify independent tasks for parallelization
- Use sequential execution for dependent tasks
- Monitor resource usage during parallel execution
- Implement proper error handling

### 4. Memory Management

- Use namespaces to organize memory
- Set appropriate TTL values
- Create regular backups
- Implement state snapshots for checkpoints

### 5. Monitoring and Optimization

- Monitor swarm health regularly
- Collect and analyze metrics
- Optimize topology based on performance
- Use neural patterns to learn from success

### 6. Error Recovery

- Implement fault tolerance strategies
- Use auto-recovery mechanisms
- Analyze error patterns
- Create fallback workflows

## Real-World Examples

### Example 1: AI Research Project

```javascript
// Research AI trends, analyze findings, generate report
mcp__claude - flow__swarm_init({ topology: "mesh", maxAgents: 6 });
// Spawn: 2 researchers, 2 analysts, 1 synthesizer, 1 documenter
// Parallel gather → Analyze patterns → Synthesize → Report
```

### Example 2: Full-Stack Application

```javascript
// Build complete web application with testing
mcp__claude - flow__swarm_init({ topology: "hierarchical", maxAgents: 8 });
// Spawn: 1 architect, 2 devs, 1 db engineer, 2 testers, 1 reviewer, 1 devops
// Design → Parallel implement → Test → Review → Deploy
```

### Example 3: Security Audit

```javascript
// Comprehensive security analysis
mcp__claude - flow__swarm_init({ topology: "star", maxAgents: 5 });
// Spawn: 1 coordinator, 1 code analyzer, 1 security scanner, 1 penetration tester, 1 reporter
// Parallel scan → Vulnerability analysis → Penetration test → Report
```

### Example 4: Performance Optimization

```javascript
// Identify and fix performance bottlenecks
mcp__claude - flow__swarm_init({ topology: "mesh", maxAgents: 4 });
// Spawn: 1 profiler, 1 bottleneck analyzer, 1 optimizer, 1 tester
// Profile → Identify bottlenecks → Optimize → Validate
```

## Troubleshooting

### Common Issues

**Issue**: Swarm agents not coordinating properly
**Solution**: Check topology selection, verify memory usage, enable monitoring

**Issue**: Parallel execution failing
**Solution**: Verify task dependencies, check resource limits, implement error handling

**Issue**: Memory persistence not working
**Solution**: Verify namespaces, check TTL settings, ensure backup configuration

**Issue**: Performance degradation
**Solution**: Optimize topology, reduce agent count, analyze bottlenecks

## Related Skills

- `sparc-methodology` - Systematic development workflow
- `github-integration` - Repository management and automation
- `neural-patterns` - AI-powered coordination optimization
- `memory-management` - Cross-session state persistence

## References

- [Claude Flow Documentation](https://github.com/ruvnet/claude-flow)
- [Swarm Orchestration Guide](https://github.com/ruvnet/claude-flow/wiki/swarm)
- [MCP Tools Reference](https://github.com/ruvnet/claude-flow/wiki/mcp)
- [Performance Optimization](https://github.com/ruvnet/claude-flow/wiki/performance)

---

**Version**: 2.0.0
**Last Updated**: 2025-10-19
**Skill Level**: Advanced
**Estimated Learning Time**: 2-3 hours