Cloud Swarm Orchestration

Deploy, coordinate, and scale multi-agent swarms in Flow Nexus cloud for complex task execution.

Quick Start

// Initialize a swarm with mesh topology
mcp__flow-nexus__swarm_init({
  topology: "mesh",
  maxAgents: 8,
  strategy: "balanced"
})

// Deploy specialized agents
mcp__flow-nexus__agent_spawn({ type: "researcher", name: "Lead Researcher" })
mcp__flow-nexus__agent_spawn({ type: "coder", name: "Implementation Expert" })

// Orchestrate a complex task
mcp__flow-nexus__task_orchestrate({
  task: "Build authentication API with JWT tokens",
  strategy: "parallel",
  priority: "high"
})

When to Use

• Deploying multi-agent systems for complex problem-solving
• Orchestrating parallel task execution across specialized agents
• Scaling AI workloads dynamically based on requirements
• Coordinating distributed workflows with agent collaboration
• Setting up hierarchical or mesh-based agent coordination

Prerequisites

• Flow Nexus account with active session
• MCP server flow-nexus configured: claude mcp add flow-nexus npx flow-nexus@latest mcp start
• Sufficient rUv credits for agent deployment

Core Concepts

Swarm Topologies

Agent Types

Distribution Strategies

• balanced: Even distribution across agent capabilities
• specialized: Focus on specific agent types for task needs
• adaptive: Dynamic adjustment based on workload

MCP Tools Reference

Swarm Initialization

mcp__flow-nexus__swarm_init({
  topology: "hierarchical",  // mesh, ring, star, hierarchical
  maxAgents: 8,              // Maximum agents in swarm (1-100)
  strategy: "balanced"       // balanced, specialized, adaptive
})
// Returns: { swarm_id, topology, status, agents: [] }

Agent Deployment

mcp__flow-nexus__agent_spawn({
  type: "researcher",        // researcher, coder, analyst, optimizer, coordinator
  name: "Agent Name",        // Custom identifier
  capabilities: ["web_search", "analysis", "summarization"]
})
// Returns: { agent_id, type, name, status, capabilities }

Task Orchestration

mcp__flow-nexus__task_orchestrate({
  task: "Task description",  // What to accomplish
  strategy: "parallel",      // parallel, sequential, adaptive
  maxAgents: 5,              // Agents to assign (1-10)
  priority: "high"           // low, medium, high, critical
})
// Returns: { task_id, status, assigned_agents, strategy }

Swarm Management

// Check swarm status
mcp__flow-nexus__swarm_status({ swarm_id: "optional" })

// List all swarms
mcp__flow-nexus__swarm_list({ status: "active" })  // active, destroyed, all

// Scale swarm
mcp__flow-nexus__swarm_scale({ target_agents: 10 })

// Destroy swarm
mcp__flow-nexus__swarm_destroy({ swarm_id: "id" })

Template-Based Creation

// List available templates
mcp__flow-nexus__swarm_templates_list({
  category: "quickstart",    // quickstart, specialized, enterprise, custom, all
  includeStore: true
})

// Create from template
mcp__flow-nexus__swarm_create_from_template({
  template_id: "template_id",
  overrides: { maxAgents: 10, strategy: "adaptive" }
})

Usage Examples

Example 1: Research and Development Swarm

// Step 1: Initialize hierarchical swarm for R&D
const swarm = await mcp__flow-nexus__swarm_init({
  topology: "hierarchical",
  maxAgents: 6,
  strategy: "specialized"
});

// Step 2: Deploy specialized agents
await mcp__flow-nexus__agent_spawn({
  type: "researcher",
  name: "Market Researcher",
  capabilities: ["web_search", "trend_analysis"]
});

await mcp__flow-nexus__agent_spawn({
  type: "analyst",
  name: "Data Analyst",
  capabilities: ["data_processing", "visualization"]
});

await mcp__flow-nexus__agent_spawn({
  type: "coder",
  name: "Prototype Developer",
  capabilities: ["rapid_prototyping", "api_development"]
});

// Step 3: Orchestrate research task
await mcp__flow-nexus__task_orchestrate({
  task: "Research competitor authentication solutions and prototype an improved version",
  strategy: "sequential",
  maxAgents: 3,
  priority: "high"
});

// Step 4: Monitor progress
const status = await mcp__flow-nexus__swarm_status();
console.log(`Active agents: ${status.agents.length}, Tasks: ${status.active_tasks}`);

Example 2: Parallel Processing with Mesh Topology

// Initialize mesh for collaborative processing
await mcp__flow-nexus__swarm_init({
  topology: "mesh",
  maxAgents: 8,
  strategy: "balanced"
});

// Deploy multiple coders for parallel work
for (const module of ["auth", "api", "database", "frontend"]) {
  await mcp__flow-nexus__agent_spawn({
    type: "coder",
    name: `${module}-developer`,
    capabilities: ["implementation", "testing"]
  });
}

// Orchestrate parallel development
await mcp__flow-nexus__task_orchestrate({
  task: "Build microservices architecture with 4 independent modules",
  strategy: "parallel",
  maxAgents: 4,
  priority: "critical"
});

// Scale up if needed
await mcp__flow-nexus__swarm_scale({ target_agents: 12 });

Example 3: Using Templates

// List available templates
const templates = await mcp__flow-nexus__swarm_templates_list({
  category: "enterprise",
  includeStore: true
});

// Deploy from template
await mcp__flow-nexus__swarm_create_from_template({
  template_name: "full-stack-development",
  overrides: {
    maxAgents: 10,
    strategy: "adaptive"
  }
});

Execution Checklist

• Verify Flow Nexus authentication status
• Choose appropriate topology for task requirements
• Initialize swarm with correct parameters
• Deploy agents with relevant capabilities
• Orchestrate tasks with suitable strategy
• Monitor swarm performance and agent utilization
• Scale swarm based on workload
• Clean up: destroy swarm when complete

Best Practices

1. Topology Selection: Choose hierarchical for complex projects, mesh for collaboration, ring for sequential workflows
2. Agent Specialization: Deploy agents with capabilities matching task requirements
3. Resource Efficiency: Start with fewer agents and scale up as needed
4. Task Decomposition: Break complex objectives into manageable sub-tasks
5. Monitoring: Regularly check swarm status and agent utilization
6. Cleanup: Always destroy swarms when work is complete to free resources

Error Handling

Metrics & Success Criteria

• Agent Utilization: Target >80% utilization during active tasks
• Task Completion: All orchestrated tasks complete successfully
• Response Time: Swarm initialization <5 seconds
• Scaling Efficiency: Scale operations complete <10 seconds

Integration Points

With Workflows

// Create workflow that uses swarm
await mcp__flow-nexus__workflow_create({
  name: "Swarm-Powered Pipeline",
  steps: [
    { id: "init", action: "swarm_init", config: { topology: "mesh" } },
    { id: "deploy", action: "agent_spawn", depends: ["init"] },
    { id: "execute", action: "task_orchestrate", depends: ["deploy"] }
  ]
});

With Sandboxes

// Deploy agents with sandbox execution capabilities
await mcp__flow-nexus__agent_spawn({
  type: "coder",
  name: "Sandbox Developer",
  capabilities: ["sandbox_execution", "code_testing"]
});

Related Skills

• cloud-workflow - Event-driven workflow automation
• cloud-neural - Neural network training and deployment
• cloud-sandbox - Isolated execution environments

References

• Flow Nexus Documentation
• Swarm Topology Guide

Version History

• 1.0.0 (2026-01-02): Initial release - converted from flow-nexus-swarm agent