Claude Skill

Swarm Orchestration

Orchestrate multi-agent swarms with agentic-flow for parallel task execution, dynamic topology, and intelligent coordination. Use when scaling beyond single agents, implementing complex workflows, or building distributed AI systems.

LLM Mart · 0 points · 1 views 0 listing impressions 0 install-command copies
Download spencermarx-open-code-review-.claude_skills_swarm-orchestration-a793b05.zip · 1 KB

Install

skills CLI npx skills add https://github.com/spencermarx/open-code-review/tree/main/.claude/skills/swarm-orchestration
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install spencermarx-open-code-review@llmmart
Git git clone https://github.com/spencermarx/open-code-review.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole spencermarx/open-code-review collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Swarm Orchestration

What This Skill Does

Orchestrates multi-agent swarms using agentic-flow's advanced coordination system. Supports mesh, hierarchical, and adaptive topologies with automatic task distribution, load balancing, and fault tolerance.

Prerequisites

  • agentic-flow v3.0.0-alpha.1+
  • Node.js 18+
  • Understanding of distributed systems (helpful)

Quick Start

# Initialize swarm
npx agentic-flow hooks swarm-init --topology mesh --max-agents 5

# Spawn agents
npx agentic-flow hooks agent-spawn --type coder
npx agentic-flow hooks agent-spawn --type tester
npx agentic-flow hooks agent-spawn --type reviewer

# Orchestrate task
npx agentic-flow hooks task-orchestrate \
  --task "Build REST API with tests" \
  --mode parallel

Topology Patterns

1. Mesh (Peer-to-Peer)

// Equal peers, distributed decision-making
await swarm.init({
  topology: 'mesh',
  agents: ['coder', 'tester', 'reviewer'],
  communication: 'broadcast'
});

2. Hierarchical (Queen-Worker)

// Centralized coordination, specialized workers
await swarm.init({
  topology: 'hierarchical',
  queen: 'architect',
  workers: ['backend-dev', 'frontend-dev', 'db-designer']
});

3. Adaptive (Dynamic)

// Automatically switches topology based on task
await swarm.init({
  topology: 'adaptive',
  optimization: 'task-complexity'
});

Task Orchestration

Parallel Execution

// Execute tasks concurrently
const results = await swarm.execute({
  tasks: [
    { agent: 'coder', task: 'Implement API endpoints' },
    { agent: 'frontend', task: 'Build UI components' },
    { agent: 'tester', task: 'Write test suite' }
  ],
  mode: 'parallel',
  timeout: 300000 // 5 minutes
});

Pipeline Execution

// Sequential pipeline with dependencies
await swarm.pipeline([
  { stage: 'design', agent: 'architect' },
  { stage: 'implement', agent: 'coder', after: 'design' },
  { stage: 'test', agent: 'tester', after: 'implement' },
  { stage: 'review', agent: 'reviewer', after: 'test' }
]);

Adaptive Execution

// Let swarm decide execution strategy
await swarm.autoOrchestrate({
  goal: 'Build production-ready API',
  constraints: {
    maxTime: 3600,
    maxAgents: 8,
    quality: 'high'
  }
});

Memory Coordination

// Share state across swarm
await swarm.memory.store('api-schema', {
  endpoints: [...],
  models: [...]
});

// Agents read shared memory
const schema = await swarm.memory.retrieve('api-schema');

Advanced Features

Load Balancing

// Automatic work distribution
await swarm.enableLoadBalancing({
  strategy: 'dynamic',
  metrics: ['cpu', 'memory', 'task-queue']
});

Fault Tolerance

// Handle agent failures
await swarm.setResiliency({
  retry: { maxAttempts: 3, backoff: 'exponential' },
  fallback: 'reassign-task'
});

Performance Monitoring

// Track swarm metrics
const metrics = await swarm.getMetrics();
// { throughput, latency, success_rate, agent_utilization }

Integration with Hooks

# Pre-task coordination
npx agentic-flow hooks pre-task --description "Build API"

# Post-task synchronization
npx agentic-flow hooks post-task --task-id "task-123"

# Session restore
npx agentic-flow hooks session-restore --session-id "swarm-001"

Best Practices

  1. Start small: Begin with 2-3 agents, scale up
  2. Use memory: Share context through swarm memory
  3. Monitor metrics: Track performance and bottlenecks
  4. Enable hooks: Automatic coordination and sync
  5. Set timeouts: Prevent hung tasks

Troubleshooting

Issue: Agents not coordinating

Solution: Verify memory access and enable hooks

Issue: Poor performance

Solution: Check topology (use adaptive) and enable load balancing

Learn More

  • Swarm Guide: docs/swarm/orchestration.md
  • Topology Patterns: docs/swarm/topologies.md
  • Hooks Integration: docs/hooks/coordination.md
Files (open-code-review)
  • SKILL.md 4.2 KB
    ---
    name: "Swarm Orchestration"
    description: "Orchestrate multi-agent swarms with agentic-flow for parallel task execution, dynamic topology, and intelligent coordination. Use when scaling beyond single agents, implementing complex workflows, or building distributed AI systems."
    ---
    
    # Swarm Orchestration
    
    ## What This Skill Does
    
    Orchestrates multi-agent swarms using agentic-flow's advanced coordination system. Supports mesh, hierarchical, and adaptive topologies with automatic task distribution, load balancing, and fault tolerance.
    
    ## Prerequisites
    
    - agentic-flow v3.0.0-alpha.1+
    - Node.js 18+
    - Understanding of distributed systems (helpful)
    
    ## Quick Start
    
    ```bash
    # Initialize swarm
    npx agentic-flow hooks swarm-init --topology mesh --max-agents 5
    
    # Spawn agents
    npx agentic-flow hooks agent-spawn --type coder
    npx agentic-flow hooks agent-spawn --type tester
    npx agentic-flow hooks agent-spawn --type reviewer
    
    # Orchestrate task
    npx agentic-flow hooks task-orchestrate \
      --task "Build REST API with tests" \
      --mode parallel
    ```
    
    ## Topology Patterns
    
    ### 1. Mesh (Peer-to-Peer)
    ```typescript
    // Equal peers, distributed decision-making
    await swarm.init({
      topology: 'mesh',
      agents: ['coder', 'tester', 'reviewer'],
      communication: 'broadcast'
    });
    ```
    
    ### 2. Hierarchical (Queen-Worker)
    ```typescript
    // Centralized coordination, specialized workers
    await swarm.init({
      topology: 'hierarchical',
      queen: 'architect',
      workers: ['backend-dev', 'frontend-dev', 'db-designer']
    });
    ```
    
    ### 3. Adaptive (Dynamic)
    ```typescript
    // Automatically switches topology based on task
    await swarm.init({
      topology: 'adaptive',
      optimization: 'task-complexity'
    });
    ```
    
    ## Task Orchestration
    
    ### Parallel Execution
    ```typescript
    // Execute tasks concurrently
    const results = await swarm.execute({
      tasks: [
        { agent: 'coder', task: 'Implement API endpoints' },
        { agent: 'frontend', task: 'Build UI components' },
        { agent: 'tester', task: 'Write test suite' }
      ],
      mode: 'parallel',
      timeout: 300000 // 5 minutes
    });
    ```
    
    ### Pipeline Execution
    ```typescript
    // Sequential pipeline with dependencies
    await swarm.pipeline([
      { stage: 'design', agent: 'architect' },
      { stage: 'implement', agent: 'coder', after: 'design' },
      { stage: 'test', agent: 'tester', after: 'implement' },
      { stage: 'review', agent: 'reviewer', after: 'test' }
    ]);
    ```
    
    ### Adaptive Execution
    ```typescript
    // Let swarm decide execution strategy
    await swarm.autoOrchestrate({
      goal: 'Build production-ready API',
      constraints: {
        maxTime: 3600,
        maxAgents: 8,
        quality: 'high'
      }
    });
    ```
    
    ## Memory Coordination
    
    ```typescript
    // Share state across swarm
    await swarm.memory.store('api-schema', {
      endpoints: [...],
      models: [...]
    });
    
    // Agents read shared memory
    const schema = await swarm.memory.retrieve('api-schema');
    ```
    
    ## Advanced Features
    
    ### Load Balancing
    ```typescript
    // Automatic work distribution
    await swarm.enableLoadBalancing({
      strategy: 'dynamic',
      metrics: ['cpu', 'memory', 'task-queue']
    });
    ```
    
    ### Fault Tolerance
    ```typescript
    // Handle agent failures
    await swarm.setResiliency({
      retry: { maxAttempts: 3, backoff: 'exponential' },
      fallback: 'reassign-task'
    });
    ```
    
    ### Performance Monitoring
    ```typescript
    // Track swarm metrics
    const metrics = await swarm.getMetrics();
    // { throughput, latency, success_rate, agent_utilization }
    ```
    
    ## Integration with Hooks
    
    ```bash
    # Pre-task coordination
    npx agentic-flow hooks pre-task --description "Build API"
    
    # Post-task synchronization
    npx agentic-flow hooks post-task --task-id "task-123"
    
    # Session restore
    npx agentic-flow hooks session-restore --session-id "swarm-001"
    ```
    
    ## Best Practices
    
    1. **Start small**: Begin with 2-3 agents, scale up
    2. **Use memory**: Share context through swarm memory
    3. **Monitor metrics**: Track performance and bottlenecks
    4. **Enable hooks**: Automatic coordination and sync
    5. **Set timeouts**: Prevent hung tasks
    
    ## Troubleshooting
    
    ### Issue: Agents not coordinating
    **Solution**: Verify memory access and enable hooks
    
    ### Issue: Poor performance
    **Solution**: Check topology (use adaptive) and enable load balancing
    
    ## Learn More
    
    - Swarm Guide: docs/swarm/orchestration.md
    - Topology Patterns: docs/swarm/topologies.md
    - Hooks Integration: docs/hooks/coordination.md
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.