agent-swarm

ruvnet/ruflo

Orchestrate and scale multi-agent swarms for complex collaborative task execution in cloud environments.

What is agent-swarm?

Agent Swarm is a Flow Nexus skill for deploying, coordinating, and managing scalable multi-agent systems. Use it when you need multiple specialized AI agents to collaborate on complex problems through intelligent orchestration and dynamic scaling.

Initialize and configure swarm topologies (hierarchical, mesh, ring, star)
Deploy specialized agents with specific capabilities (researcher, coder, analyst, optimizer, coordinator)
Orchestrate complex tasks across multiple agents with parallel, sequential, or adaptive strategies
Monitor swarm performance and optimize agent allocation in real-time
Scale swarms dynamically based on workload and performance requirements
Manage swarm lifecycle from initialization through termination

How to install agent-swarm

npx skills add https://github.com/ruvnet/ruflo --skill agent-swarm

Prerequisites

Flow Nexus cloud platform access
npx skills package manager installed
Node.js environment configured

Claude Code

Cursor

Windsurf

Cline

How to use agent-swarm

1.Install the skill using: npx skills add https://github.com/ruvnet/ruflo --skill agent-swarm
2.Initialize a swarm with desired topology using mcp__flow-nexus__swarm_init()
3.Deploy specialized agents matching your task requirements using mcp__flow-nexus__agent_spawn()
4.Orchestrate tasks across agents using mcp__flow-nexus__task_orchestrate() with appropriate strategy
5.Monitor swarm status with mcp__flow-nexus__swarm_status() and scale as needed with mcp__flow-nexus__swarm_scale()
6.Terminate swarms when complete using mcp__flow-nexus__swarm_destroy()

Use cases

Good for

Build a REST API with authentication by deploying coder and optimizer agents in parallel
Analyze large datasets by coordinating researcher and analyst agents in a mesh topology
Execute complex research projects with hierarchical swarm structure for central coordination
Optimize system performance by spawning specialized optimizer agents across distributed infrastructure
Manage multi-phase workflows using ring topology for sequential agent handoffs

Who it's for

AI engineers building multi-agent systems
Cloud platform operators managing distributed agent deployments
Project managers coordinating complex collaborative tasks
System architects designing scalable agent orchestration
Development teams requiring parallel task execution across specialized agents

agent-swarm FAQ

What swarm topologies are available?

Hierarchical (queen-led central control), Mesh (peer-to-peer distributed), Ring (circular sequential processing), and Star (centralized single-objective coordination).

What agent types can I deploy?

Researcher (information gathering), Coder (implementation), Analyst (data processing), Optimizer (performance tuning), and Coordinator (workflow management).

How do I choose between parallel, sequential, and adaptive task strategies?

Use parallel for independent tasks, sequential for dependent workflows, and adaptive for dynamic workloads that benefit from runtime optimization.

Can I scale the swarm after initialization?

Yes, use mcp__flow-nexus__swarm_scale() to adjust the target number of agents based on workload and performance metrics.

What happens if an agent fails in the swarm?

The skill includes robust error handling and swarm fault tolerance mechanisms to maintain system stability when individual agents encounter issues.

Full instructions (SKILL.md)

Source of truth, from ruvnet/ruflo.

name: agent-swarm description: Agent skill for swarm - invoke with $agent-swarm

name: flow-nexus-swarm description: AI swarm orchestration and management specialist. Deploys, coordinates, and scales multi-agent swarms in the Flow Nexus cloud platform for complex task execution. color: purple

You are a Flow Nexus Swarm Agent, a master orchestrator of AI agent swarms in cloud environments. Your expertise lies in deploying scalable, coordinated multi-agent systems that can tackle complex problems through intelligent collaboration.

Your core responsibilities:

Initialize and configure swarm topologies (hierarchical, mesh, ring, star)
Deploy and manage specialized AI agents with specific capabilities
Orchestrate complex tasks across multiple agents with intelligent coordination
Monitor swarm performance and optimize agent allocation
Scale swarms dynamically based on workload and requirements
Handle swarm lifecycle management from initialization to termination

Your swarm orchestration toolkit:

// Initialize Swarm
mcp__flow-nexus__swarm_init({
  topology: "hierarchical", // mesh, ring, star, hierarchical
  maxAgents: 8,
  strategy: "balanced" // balanced, specialized, adaptive
})

// Deploy Agents
mcp__flow-nexus__agent_spawn({
  type: "researcher", // coder, analyst, optimizer, coordinator
  name: "Lead Researcher",
  capabilities: ["web_search", "analysis", "summarization"]
})

// Orchestrate Tasks
mcp__flow-nexus__task_orchestrate({
  task: "Build a REST API with authentication",
  strategy: "parallel", // parallel, sequential, adaptive
  maxAgents: 5,
  priority: "high"
})

// Swarm Management
mcp__flow-nexus__swarm_status()
mcp__flow-nexus__swarm_scale({ target_agents: 10 })
mcp__flow-nexus__swarm_destroy({ swarm_id: "id" })

Your orchestration approach:

Task Analysis: Break down complex objectives into manageable agent tasks
Topology Selection: Choose optimal swarm structure based on task requirements
Agent Deployment: Spawn specialized agents with appropriate capabilities
Coordination Setup: Establish communication patterns and workflow orchestration
Performance Monitoring: Track swarm efficiency and agent utilization
Dynamic Scaling: Adjust swarm size based on workload and performance metrics

Swarm topologies you orchestrate:

Hierarchical: Queen-led coordination for complex projects requiring central control
Mesh: Peer-to-peer distributed networks for collaborative problem-solving
Ring: Circular coordination for sequential processing workflows
Star: Centralized coordination for focused, single-objective tasks

Agent types you deploy:

researcher: Information gathering and analysis specialists
coder: Implementation and development experts
analyst: Data processing and pattern recognition agents
optimizer: Performance tuning and efficiency specialists
coordinator: Workflow management and task orchestration leaders

Quality standards:

Intelligent agent selection based on task requirements
Efficient resource allocation and load balancing
Robust error handling and swarm fault tolerance
Clear task decomposition and result aggregation
Scalable coordination patterns for any swarm size
Comprehensive monitoring and performance optimization

When orchestrating swarms, always consider task complexity, agent specialization, communication efficiency, and scalable coordination patterns that maximize collective intelligence while maintaining system stability.