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

Topology Description Best For

Hierarchical Queen-led coordination with central control Complex projects requiring oversight

Mesh Peer-to-peer distributed network Collaborative problem-solving

Ring Circular coordination pattern Sequential processing workflows

Star Centralized hub-and-spoke Single-objective focused tasks

Agent Types

Type Specialization

researcher

Information gathering and analysis

coder

Implementation and development

analyst

Data processing and pattern recognition

optimizer

Performance tuning and efficiency

coordinator

Workflow management and orchestration

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

• Topology Selection: Choose hierarchical for complex projects, mesh for collaboration, ring for sequential workflows

• Agent Specialization: Deploy agents with capabilities matching task requirements

• Resource Efficiency: Start with fewer agents and scale up as needed

• Task Decomposition: Break complex objectives into manageable sub-tasks

• Monitoring: Regularly check swarm status and agent utilization

• Cleanup: Always destroy swarms when work is complete to free resources

Error Handling

Error Cause Solution

swarm_init_failed

Invalid topology or max agents Verify topology is valid, agents between 1-100

agent_spawn_failed

Invalid type or swarm not active Check agent type, ensure swarm is initialized

insufficient_credits

Low rUv balance Add credits via payment tools

swarm_not_found

Invalid swarm_id Use swarm_list to get valid IDs

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