hive-mind-advanced

Coordinate queen-led multi-agent systems with consensus modes and persistent collective memory.

67.5k|8.1k|Updated Jun 2, 2025
One-click install
npx skills add https://github.com/ruvnet/claude-flow --skill hive-mind-advanced-ruvnet
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: hive-mind-advanced
Source: https://github.com/ruvnet/claude-flow/tree/main/.claude/skills/hive-mind-advanced
Command: npx skills add https://github.com/ruvnet/claude-flow --skill hive-mind-advanced-ruvnet

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires claude-flow, node.

What problem does it solve?

This Skill solves the challenge of complex multi-agent coordination, decision-making, and memory management. It helps automate large-scale, intricate tasks that require multiple AI agents to work together, ensuring robust consensus and shared knowledge to reduce complexity and save time.

Core Features & Use Cases

  • Queen-Led Coordination: Hierarchical agent management for strategic direction and task orchestration.
  • Byzantine Fault Tolerance: Ensures robust decision-making even with faulty agents, guaranteeing reliable outcomes.
  • Collective Memory System: A shared, persistent knowledge base across all agents for continuous learning and context.
  • Use Case: Imagine building a complex microservices architecture. Use this Skill to orchestrate a swarm of architect, coder, tester, and reviewer agents, guiding them through design, implementation, and validation with shared memory and consensus on critical decisions.

Quick Start

1. Initialize Hive Mind

npx claude-flow hive-mind init

2. Spawn a Swarm for an objective

npx claude-flow hive-mind spawn "Build microservices architecture"

Frequently Asked Questions about hive-mind-advanced

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I coordinate multiple AI agents to work together on complex tasks?

Multi-agent coordination uses a queen-led hierarchical system where a central coordinator directs specialized agents (architect, coder, tester, reviewer) toward shared objectives. This Skill implements role-based orchestration with collective memory and consensus mechanisms to ensure agents align on decisions and share context across the workflow.

What is Byzantine fault tolerance and why do I need it for multi-agent systems?

Byzantine fault tolerance is a consensus method that produces reliable decisions even when some agents provide incorrect or corrupted information. This Skill applies it to guarantee robust outcomes in multi-agent coordination, protecting against faulty agent behavior without losing overall system integrity.

How do I set up persistent memory sharing across multiple AI agents?

Persistent agent memory uses LRU caching and SQLite with WAL (write-ahead logging) to maintain a shared knowledge base accessible to all agents in the swarm. This Skill manages collective memory automatically, enabling continuous learning and context preservation across sessions.

Can I use this for automating microservices architecture design with multiple specialized agents?

Yes. This Skill is built for orchestrating swarms of specialized agents—architects, coders, testers, reviewers—through design, implementation, and validation phases. Each agent holds a distinct role; the system distributes tasks, maintains shared memory, and achieves consensus on critical decisions.

What consensus modes does this Skill support for multi-agent decision-making?

This Skill supports majority-vote, weighted, and Byzantine consensus modes. Choose majority for simple agreement, weighted to prioritize certain agent opinions, or Byzantine to tolerate faulty agents while reaching reliable consensus across complex workflows.

How does task distribution and performance monitoring work in a multi-agent swarm?

Automatic task distribution assigns work to agents based on role and capacity; performance monitoring tracks agent execution, latency, and outcomes in real time. This Skill uses these metrics to optimize task flow, identify bottlenecks, and ensure efficient collective work across the swarm.