/hive-mind-advanced

name: hive-mind-advanced
description: Advanced Hive Mind collective intelligence system for queen-led multi-agent coordination with consensus mechanisms and persistent memory
version: 1.0.0
category: coordination
tags: [hive-mind, swarm, queen-worker, consensus, collective-intelligence, multi-agent, coordination]
author: Claude Flow Team

Hive Mind Advanced Skill

Master the advanced Hive Mind collective intelligence system for sophisticated multi-agent coordination using queen-led architecture, Byzantine consensus, and collective memory.

Overview

The Hive Mind system represents the pinnacle of multi-agent coordination in Claude Flow, implementing a queen-led hierarchical architecture where a strategic queen coordinator directs specialized worker agents through collective decision-making and shared memory.

Core Concepts

Architecture Patterns

**Queen-Led Coordination**

• Strategic queen agents orchestrate high-level objectives
• Tactical queens manage mid-level execution
• Adaptive queens dynamically adjust strategies based on performance

**Worker Specialization**

• Researcher agents: Analysis and investigation
• Coder agents: Implementation and development
• Analyst agents: Data processing and metrics
• Tester agents: Quality assurance and validation
• Architect agents: System design and planning
• Reviewer agents: Code review and improvement
• Optimizer agents: Performance enhancement
• Documenter agents: Documentation generation

**Collective Memory System**

• Shared knowledge base across all agents
• LRU cache with memory pressure handling
• SQLite persistence with WAL mode
• Memory consolidation and association
• Access pattern tracking and optimization

Consensus Mechanisms

**Majority Consensus** Simple voting where the option with most votes wins.

**Weighted Consensus** Queen vote counts as 3x weight, providing strategic guidance.

**Byzantine Fault Tolerance** Requires 2/3 majority for decision approval, ensuring robust consensus even with faulty agents.

Getting Started

1. Initialize Hive Mind

# Basic initialization
npx claude-flow hive-mind init

# Force reinitialize
npx claude-flow hive-mind init --force

# Custom configuration
npx claude-flow hive-mind init --config hive-config.json

2. Spawn a Swarm

# Basic spawn with objective
npx claude-flow hive-mind spawn "Build microservices architecture"

# Strategic queen type
npx claude-flow hive-mind spawn "Research AI patterns" --queen-type strategic

# Tactical queen with max workers
npx claude-flow hive-mind spawn "Implement API" --queen-type tactical --max-workers 12

# Adaptive queen with consensus
npx claude-flow hive-mind spawn "Optimize system" --queen-type adaptive --consensus byzantine

# Generate Claude Code commands
npx claude-flow hive-mind spawn "Build full-stack app" --claude

3. Monitor Status

# Check hive mind status
npx claude-flow hive-mind status

# Get detailed metrics
npx claude-flow hive-mind metrics

# Monitor collective memory
npx claude-flow hive-mind memory

Advanced Workflows

Session Management

**Create and Manage Sessions**

# List active sessions
npx claude-flow hive-mind sessions

# Pause a session
npx claude-flow hive-mind pause <session-id>

# Resume a paused session
npx claude-flow hive-mind resume <session-id>

# Stop a running session
npx claude-flow hive-mind stop <session-id>

**Session Features**

• Automatic checkpoint creation
• Progress tracking with completion percentages
• Parent-child process management
• Session logs with event tracking
• Export/import capabilities

Consensus Building

The Hive Mind builds consensus through structured voting:

// Programmatic consensus building
const decision = await hiveMind.buildConsensus(
  'Architecture pattern selection',
  ['microservices', 'monolith', 'serverless']
);

// Result includes:
// - decision: Winning option
// - confidence: Vote percentage
// - votes: Individual agent votes

**Consensus Algorithms**

1. **Majority** - Simple democratic voting 2. **Weighted** - Queen has 3x voting power 3. **Byzantine** - 2/3 supermajority required

Collective Memory

**Storing Knowledge**

// Store in collective memory
await memory.store('api-patterns', {
  rest: { pros: [...], cons: [...] },
  graphql: { pros: [...], cons: [...] }
}, 'knowledge', { confidence: 0.95 });

**Memory Types**

• `knowledge`: Permanent insights (no TTL)
• `context`: Session context (1 hour TTL)
• `task`: Task-specific data (30 min TTL)
• `result`: Execution results (permanent, compressed)
• `error`: Error logs (24 hour TTL)
• `metric`: Performance metrics (1 hour TTL)
• `consensus`: Decision records (permanent)
• `system`: System configuration (permanent)

**Searching and Retrieval**

// Search memory by pattern
const results = await memory.search('api*', {
  type: 'knowledge',
  minConfidence: 0.8,
  limit: 50
});

// Get related memories
const related = await memory.getRelated('api-patterns', 10);

// Build associations
await memory.associate('rest-api', 'authentication', 0.9);

Task Distribution

**Automatic Worker Assignment**

The system intelligently assigns tasks based on:

• Keyword matching with agent specialization
• Historical performance metrics
• Worker availability and load
• Task complexity analysis

// Create task (auto-assigned)
const task = await hiveMind.createTask(
  'Implement user authentication',
  priority: 8,
  { estimatedDuration: 30000 }
);

**Auto-Scaling**

// Configure auto-scaling
const config = {
  autoScale: true,
  maxWorkers: 12,
  scaleUpThreshold: 2, // Pending tasks per idle worker
  scaleDownThreshold: 2 // Idle workers above pending tasks
};

Integration Patterns

With Claude Code

Generate Claude Code spawn commands directly:

npx claude-flow hive-mind spawn "Build REST API" --claude

Output:

Task("Qu