flowchart TB
    subgraph USER["👤 User Layer"]
        U[User]
    end

    subgraph ENTRY["🚪 Entry Layer"]
        CLI[CLI / MCP Server]
        AID[AIDefence Security]
    end

    subgraph ROUTING["🧭 Routing Layer"]
        QL[Q-Learning Router]
        MOE[MoE - 8 Experts]
        SK[Skills - 42+]
        HK[Hooks - 17]
    end

    subgraph SWARM["🐝 Swarm Coordination"]
        TOPO[Topologies<br/>mesh/hier/ring/star]
        CONS[Consensus<br/>Raft/BFT/Gossip/CRDT]
        CLM[Claims<br/>Human-Agent Coord]
    end

    subgraph AGENTS["🤖 54+ Agents"]
        AG1[coder]
        AG2[tester]
        AG3[reviewer]
        AG4[architect]
        AG5[security]
        AG6[...]
    end

    subgraph RESOURCES["📦 Resources"]
        MEM[(Memory<br/>AgentDB)]
        PROV[Providers<br/>Claude/GPT/Gemini/Ollama]
        WORK[Workers - 12<br/>ultralearn/audit/optimize]
    end

    subgraph RUVECTOR["🧠 RuVector Intelligence Layer"]
        direction TB
        subgraph ROW1[" "]
            SONA[SONA<br/>Self-Optimize<br/>&lt;0.05ms]
            EWC[EWC++<br/>No Forgetting]
            FLASH[Flash Attention<br/>2.49-7.47x]
        end
        subgraph ROW2[" "]
            HNSW[HNSW<br/>150x-12,500x faster]
            RB[ReasoningBank<br/>Pattern Store]
            HYP[Hyperbolic<br/>Poincaré]
        end
        subgraph ROW3[" "]
            LORA[LoRA/Micro<br/>128x compress]
            QUANT[Int8 Quant<br/>3.92x memory]
            RL[9 RL Algos<br/>Q/SARSA/PPO/DQN]
        end
    end

    subgraph LEARNING["🔄 Learning Loop"]
        L1[RETRIEVE] --> L2[JUDGE] --> L3[DISTILL] --> L4[CONSOLIDATE] --> L5[ROUTE]
    end

    U --> CLI
    CLI --> AID
    AID --> QL & MOE & SK & HK
    QL & MOE & SK & HK --> TOPO & CONS & CLM
    TOPO & CONS & CLM --> AG1 & AG2 & AG3 & AG4 & AG5 & AG6
    AG1 & AG2 & AG3 & AG4 & AG5 & AG6 --> MEM & PROV & WORK
    MEM --> SONA & EWC & FLASH
    SONA & EWC & FLASH --> HNSW & RB & HYP
    HNSW & RB & HYP --> LORA & QUANT & RL
    LORA & QUANT & RL --> L1
    L5 -.->|loops back| QL

    style RUVECTOR fill:#1a1a2e,stroke:#e94560,stroke-width:2px
    style LEARNING fill:#0f3460,stroke:#e94560,stroke-width:2px
    style USER fill:#16213e,stroke:#0f3460
    style ENTRY fill:#1a1a2e,stroke:#0f3460
    style ROUTING fill:#1a1a2e,stroke:#0f3460
    style SWARM fill:#1a1a2e,stroke:#0f3460
    style AGENTS fill:#1a1a2e,stroke:#0f3460
    style RESOURCES fill:#1a1a2e,stroke:#0f3460

RuVector Components (npx ruvector):

# Install RuVector standalone
npx ruvector

# Or use via Claude-Flow
npx claude-flow@v3alpha hooks intelligence --status

Every request flows through four layers: from your CLI or Claude Code interface, through intelligent routing, to specialized agents, and finally to LLM providers for reasoning.

Agents organize into swarms led by queens that coordinate work, prevent drift, and reach consensus on decisions—even when some agents fail.

Hive Mind Capabilities:

• 🐝 Queen Types: Strategic (planning), Tactical (execution), Adaptive (optimization)
• 👷 8 Worker Types: Researcher, Coder, Analyst, Tester, Architect, Reviewer, Optimizer, Documenter
• 🗳️ 3 Consensus Algorithms: Majority, Weighted (Queen 3x), Byzantine (f < n/3)
• 🧠 Collective Memory: Shared knowledge, LRU cache, SQLite persistence with WAL
• ⚡ Performance: 10-20x faster batch spawning, 84.8% SWE-Bench solve rate

The system stores successful patterns in vector memory, learns from outcomes via neural networks, and adapts routing based on what works best.

Skip expensive LLM calls for simple tasks using WebAssembly transforms, and compress tokens to reduce API costs by 30-50%.

Background daemons handle security audits, performance optimization, and session persistence automatically while you work.

Smart routing skips expensive LLM calls when possible. Simple edits use WASM (free), medium tasks use cheaper models. This can extend your Claude Code usage by 250% or save significantly on direct API costs.

What makes Claude-Flow different from other agent frameworks? These 10 capabilities work together to create a system that learns from experience, runs efficiently on any hardware, and keeps working even when things go wrong.

Not every task needs the most powerful (and expensive) model. Claude-Flow analyzes each request and automatically routes it to the cheapest handler that can do the job well. Simple code transforms skip the LLM entirely using WebAssembly. Medium tasks use faster, cheaper models. Only complex architecture decisions use Opus.

Cost & Usage Benefits:

Routing Tiers:

Benchmark Results: 100% routing accuracy, 0.57ms avg routing decision latency

Complex projects fail when implementation drifts from the original plan. Claude-Flow solves this with a spec-first approach: define your architecture through ADRs (Architecture Decision Records), organize code into DDD bounded contexts, and let the system enforce compliance as agents work. The result is implementations that match specifications — even across multi-agent swarms working in parallel.

How It Prevents Drift:

Specification Features:

DDD Bounded Contexts:

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│    Core     │  │   Memory    │  │  Security   │
│  Agents,    │  │  AgentDB,   │  │  AIDefence, │
│  Swarms,    │  │  HNSW,      │  │  Validation │
│  Tasks      │  │  Cache      │  │  CVE Fixes  │
└─────────────┘  └─────────────┘  └─────────────┘
┌─────────────┐  ┌─────────────┐
│ Integration │  │Coordination │
│ agentic-    │  │  Consensus, │
│ flow,MCP    │  │  Hive-Mind  │
└─────────────┘  └─────────────┘

Key ADRs:

• ADR-001: agentic-flow@alpha as foundation (eliminates 10,000+ duplicate lines)
• ADR-006: Unified Memory Service with AgentDB
• ADR-008: Vitest testing framework (10x faster than Jest)
• ADR-009: Hybrid Memory Backend (SQLite + HNSW)
• ADR-026: Intelligent 3-tier model routing

flowchart TB
    subgraph User["👤 User Layer"]
        CC[Claude Code]
        CLI[CLI Commands]
    end

    subgraph Orchestration["🎯 Orchestration Layer"]
        MCP[MCP Server]
        Router[Intelligent Router]
        Hooks[Self-Learning Hooks]
    end

    subgraph Agents["🤖 Agent Layer"]
        Queen[Queen Coordinator]
        Workers[54+ Specialized Agents]
        Swarm[Swarm Manager]
    end

    subgraph Intelligence["🧠 Intelligence Layer"]
        SONA[SONA Learning]
        MoE[Mixture of Experts]
        HNSW[HNSW Vector Search]
    end

    subgraph Providers["☁️ Provider Layer"]
        Anthropic[Anthropic]
        OpenAI[OpenAI]
        Google[Google]
        Ollama[Ollama]
    end

    CC --> MCP
    CLI --> MCP
    MCP --> Router
    Router --> Hooks
    Hooks --> Queen
    Queen --> Workers
    Queen --> Swarm
    Workers --> Intelligence
    Intelligence --> Providers

sequenceDiagram
    participant U as User
    participant R as Router
    participant H as Hooks
    participant A as Agent Pool
    participant M as Memory
    participant P as Provider

    U->>R: Submit Task
    R->>H: pre-task hook
    H->>H: Analyze complexity

    alt Simple Task
        H->>A: Agent Booster (WASM)
        A-->>U: Result (<1ms)
    else Medium Task
        H->>A: Spawn Haiku Agent
        A->>M: Check patterns
        M-->>A: Cached context
        A->>P: LLM Call
        P-->>A: Response
        A->>H: post-task hook
        H->>M: Store patterns
        A-->>U: Result
    else Complex Task
        H->>A: Spawn Swarm
        A->>A: Coordinate agents
        A->>P: Multiple LLM calls
        P-->>A: Responses
        A->>H: post-task hook
        A-->>U: Result
    end

flowchart LR
    subgraph Input["📥 Input"]
        Query[Query/Pattern]
    end

    subgraph Processing["⚙️ Processing"]
        Embed[ONNX Embeddings]
        Normalize[Normalization]
    end

    subgraph Storage["💾 Storage"]
        HNSW[(HNSW Index<br/>150x faster)]
        SQLite[(SQLite Cache)]
        AgentDB[(AgentDB)]
    end

    subgraph Retrieval["🔍 Retrieval"]
        Vector[Vector Search]
        Semantic[Semantic Match]
        Results[Top-K Results]
    end

    Query --> Embed
    Embed --> Normalize
    Normalize --> HNSW
    Normalize --> SQLite
    HNSW --> Vector
    SQLite --> Vector
    AgentDB --> Semantic
    Vector --> Results
    Semantic --> Results

flowchart TB
    subgraph Hierarchical["👑 Hierarchical (Default)"]
        Q1[Queen] --> W1[Worker 1]
        Q1 --> W2[Worker 2]
        Q1 --> W3[Worker 3]
    end

    subgraph Mesh["🕸️ Mesh"]
        M1[Agent] <--> M2[Agent]
        M2 <--> M3[Agent]
        M3 <--> M1[Agent]
    end

    subgraph Ring["💍 Ring"]
        R1[Agent] --> R2[Agent]
        R2 --> R3[Agent]
        R3 --> R1
    end

    subgraph Star["⭐ Star"]
        S1[Hub] --> S2[Agent]
        S1 --> S3[Agent]
        S1 --> S4[Agent]
    end

flowchart TB
    subgraph Input["📥 Input Validation"]
        Req[Request] --> Scan[AIDefence Scan]
        Scan --> PII[PII Detection]
        Scan --> Inject[Injection Check]
        Scan --> Jailbreak[Jailbreak Detection]
    end

    subgraph Decision["⚖️ Decision"]
        PII --> Risk{Risk Level}
        Inject --> Risk
        Jailbreak --> Risk
    end

    subgraph Action["🎬 Action"]
        Risk -->|Safe| Allow[✅ Allow]
        Risk -->|Warning| Sanitize[🧹 Sanitize]
        Risk -->|Threat| Block[⛔ Block]
    end

    subgraph Learn["📚 Learning"]
        Allow --> Log[Log Pattern]
        Sanitize --> Log
        Block --> Log
        Log --> Update[Update Model]
    end

Claude-Flow runs as an MCP (Model Context Protocol) server, allowing you to connect it to any MCP-compatible AI client. This means you can use Claude-Flow's 54+ agents, swarm coordination, and self-learning capabilities from Claude Desktop, VS Code, Cursor, Windsurf, ChatGPT, and more.

Quick Add Command

# Start Claude-Flow MCP server in any environment
npx claude-flow@v3alpha mcp start

{
  "mcpServers": {
    "claude-flow": {
      "command": "npx",
      "args": ["claude-flow@v3alpha", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

# Add via CLI (recommended)
claude mcp add claude-flow -- npx claude-flow@v3alpha mcp start

# Or add with environment variables
claude mcp add claude-flow \
  --env ANTHROPIC_API_KEY=sk-ant-... \
  -- npx claude-flow@v3alpha mcp start

# Verify installation
claude mcp list

{
  "mcpServers": {
    "claude-flow": {
      "command": "npx",
      "args": ["claude-flow@v3alpha", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

{
  "mcpServers": {
    "claude-flow": {
      "command": "npx",
      "args": ["claude-flow@v3alpha", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

{
  "mcpServers": {
    "claude-flow": {
      "command": "npx",
      "args": ["claude-flow@v3alpha", "mcp", "start"],
      "env": {
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

# Start with HTTP transport
npx claude-flow@v3alpha mcp start --transport http --port 3000

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({ apiKey: 'YOUR_API_KEY' });

// MCP definitions are natively supported in the Gen AI SDK
const mcpConfig = {
  servers: [{
    name: 'claude-flow',
    command: 'npx',
    args: ['claude-flow@v3alpha', 'mcp', 'start']
  }]
};

{
  "name": "claude-flow",
  "command": "npx",
  "args": ["claude-flow@v3alpha", "mcp", "start"]
}

Environment Variables

All configurations support these environment variables:

MCP Tool Groups

Control which MCP tools are loaded to reduce latency and token usage:

# Enable specific tool groups
export CLAUDE_FLOW_TOOL_GROUPS=implement,test,fix,memory

# Or use a preset mode
export CLAUDE_FLOW_TOOL_MODE=develop

Available Groups: create, issue, branch, implement, test, fix, optimize, monitor, security, memory, all, minimal

Preset Modes:

Precedence: CLI args (--tools=X) > Environment vars > Config file > Default (all)

Security Best Practices

⚠️ Never hardcode API keys in config files checked into version control.

# Use environment variables instead
export ANTHROPIC_API_KEY="sk-ant-..."

# Or use a .env file (add to .gitignore)
echo "ANTHROPIC_API_KEY=sk-ant-..." >> .env

Comprehensive feature set for enterprise-grade AI agent orchestration.

npx claude-flow hive-mind init                    # Initialize hive mind
npx claude-flow hive-mind spawn "Build API"       # Spawn with objective
npx claude-flow hive-mind spawn "..." --queen-type strategic --consensus byzantine
npx claude-flow hive-mind status                  # Check status
npx claude-flow hive-mind metrics                 # Performance metrics
npx claude-flow hive-mind memory                  # Collective memory stats
npx claude-flow hive-mind sessions                # List active sessions

import { createRuVectorBridge } from '@claude-flow/plugins';

const bridge = createRuVectorBridge({
  host: 'localhost',
  port: 5432,
  database: 'vectors',
  user: 'postgres',
  password: 'secret',
  pool: { min: 2, max: 10 },
  ssl: true
});

// Enable the plugin
await registry.register(bridge);
await registry.loadAll();

import { createHyperbolicSpace } from '@claude-flow/plugins';

const space = createHyperbolicSpace('poincare', { curvature: -1.0 });

// Embed hierarchical data (trees, taxonomies)
const embedding = await space.embed(vector);
const distance = await space.distance(v1, v2);  // Geodesic distance
const midpoint = await space.geodesicMidpoint(v1, v2);

import { createSelfLearningSystem } from '@claude-flow/plugins';

const learning = createSelfLearningSystem(bridge);

// Automatic optimization
await learning.startLearningLoop();  // Runs in background

// Manual optimization
const suggestions = await learning.queryOptimizer.analyze(query);
await learning.indexTuner.tune('my_index');

npx claude-flow@v3alpha worker dispatch --trigger audit --context "./src"
npx claude-flow@v3alpha worker status

# Initialize ONNX embeddings with hyperbolic config
claude-flow embeddings init

# Use larger model for higher quality
claude-flow embeddings init --model all-mpnet-base-v2

# Semantic search
claude-flow embeddings search -q "authentication patterns"

# Initialize RuVector in PostgreSQL
claude-flow ruvector init --database mydb --user admin

# Check connection and schema status
claude-flow ruvector status --verbose

# Run pending migrations
claude-flow ruvector migrate --up

# Performance benchmark
claude-flow ruvector benchmark --iterations 1000

# Optimize indices and vacuum
claude-flow ruvector optimize --analyze

# Backup vector data
claude-flow ruvector backup --output ./backup.sql

npx claude-flow hive-mind init                                    # Initialize
npx claude-flow hive-mind spawn "Build API" --queen-type tactical # Spawn swarm
npx claude-flow hive-mind spawn "Research AI" --consensus byzantine --claude
npx claude-flow hive-mind status                                  # Check status

▊ Claude Flow V3 ● ruvnet  │  ⎇ v3  │  Opus 4.5
─────────────────────────────────────────────────────
🏗️  DDD Domains    [●●●●●]  5/5    ⚡ 1.0x → 2.49x-7.47x
🤖 Swarm  ◉ [58/15]  👥 0    🟢 CVE 3/3    💾 22282MB    📂  47%    🧠  10%
🔧 Architecture    DDD ● 98%  │  Security ●CLEAN  │  Memory ●AgentDB  │  Integration ●

# V3 statusline (Node.js)
node v3/@claude-flow/hooks/bin/statusline.js

# JSON output for scripting
node v3/@claude-flow/hooks/bin/statusline.js --json

# Compact JSON (single line)
node v3/@claude-flow/hooks/bin/statusline.js --compact

# Help
node v3/@claude-flow/hooks/bin/statusline.js --help

{
  "statusLine": {
    "type": "command",
    "command": "node v3/@claude-flow/hooks/bin/statusline.js"
  }
}

# Start daemon (auto-runs on SessionStart hooks)
npx claude-flow@v3alpha daemon start

# Check status with worker history
npx claude-flow@v3alpha daemon status

# Manually trigger a worker
npx claude-flow@v3alpha daemon trigger map

# Enable/disable workers
npx claude-flow@v3alpha daemon enable map audit optimize

# Stop daemon
npx claude-flow@v3alpha daemon stop

+-- Worker Daemon ---+
| Status: ● RUNNING  |
| PID: 12345         |
| Workers Enabled: 5 |
| Max Concurrent: 3  |
+--------------------+

Worker Status
+-------------+----+----------+------+---------+----------+----------+
| Worker      | On | Status   | Runs | Success | Last Run | Next Run |
+-------------+----+----------+------+---------+----------+----------+
| map         | ✓  | idle     | 12   | 100%    | 2m ago   | in 3m    |
| audit       | ✓  | idle     | 6    | 100%    | 5m ago   | in 5m    |
| optimize    | ✓  | running  | 4    | 100%    | now      | -        |
| consolidate | ✓  | idle     | 2    | 100%    | 15m ago  | in 15m   |
| testgaps    | ✓  | idle     | 3    | 100%    | 8m ago   | in 12m   |
+-------------+----+----------+------+---------+----------+----------+

# Start all daemons
.claude/helpers/daemon-manager.sh start 3 5

# Check daemon status
.claude/helpers/daemon-manager.sh status

# Stop all daemons
.claude/helpers/daemon-manager.sh stop

# Start worker manager
.claude/helpers/worker-manager.sh start 60

# Force run all workers immediately
.claude/helpers/worker-manager.sh force

# Check worker status
.claude/helpers/worker-manager.sh status

👨‍💻 Development & Code Quality

🔒 Security & Compliance

🐝 Multi-Agent Swarms

📊 Performance & Optimization

🔄 GitHub & DevOps

📋 Spec-Driven Development

🧠 Learning & Intelligence

What Are Hooks?

Hooks intercept operations (file edits, commands, tasks) and learn from outcomes. Unlike static automation, hooks improve over time by tracking what works and applying those patterns to future tasks.

How Hooks Learn (4-Step Pipeline)

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│  RETRIEVE   │───▶│    JUDGE    │───▶│   DISTILL   │───▶│ CONSOLIDATE │
│             │    │             │    │             │    │             │
│ Find similar│    │ Was it      │    │ Extract key │    │ Prevent     │
│ past patterns│   │ successful? │    │ learnings   │    │ forgetting  │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
     HNSW              Verdict            LoRA              EWC++
   150x faster        success/fail      compression       memory lock

All 27 Hooks by Category

🔧 Tool Lifecycle Hooks (6 hooks)

# Example: Edit with pattern learning
npx claude-flow@v3alpha hooks pre-edit ./src/auth.ts
npx claude-flow@v3alpha hooks post-edit ./src/auth.ts --success true --train-patterns

🧠 Intelligence & Routing Hooks (8 hooks)

# Route a task with explanation
npx claude-flow@v3alpha hooks route "refactor authentication to use JWT" --include-explanation

# Bootstrap intelligence from your codebase
npx claude-flow@v3alpha hooks pretrain --depth deep --model-type moe

📅 Session Management Hooks (4 hooks)

# Start session with auto-daemon
npx claude-flow@v3alpha hooks session-start --session-id "feature-auth" --start-daemon

# End session and export learnings
npx claude-flow@v3alpha hooks session-end --export-metrics --persist-patterns

🤖 Intelligence System Hooks (9 hooks)

# Start trajectory for complex task
npx claude-flow@v3alpha hooks intelligence trajectory-start --task "implement OAuth2"

# Record successful action
npx claude-flow@v3alpha hooks intelligence trajectory-step --action "created token service" --quality 0.9

# End trajectory and trigger learning
npx claude-flow@v3alpha hooks intelligence trajectory-end --success true

12 Background Workers (Auto-Triggered)

Workers run automatically based on context, or dispatch manually.

# List all workers
npx claude-flow@v3alpha hooks worker list

# Manually dispatch security audit
npx claude-flow@v3alpha hooks worker dispatch --trigger audit --context "./src/auth"

# Check worker status
npx claude-flow@v3alpha hooks worker status

Model Routing Hooks (3 hooks)

Automatically selects haiku/sonnet/opus based on task complexity.

# Get model recommendation
npx claude-flow@v3alpha hooks model-route --task "fix typo in README"
# → Recommends: haiku (simple task, low complexity)

npx claude-flow@v3alpha hooks model-route --task "design distributed consensus system"
# → Recommends: opus (complex architecture, high reasoning)

Progress Tracking

Quick Reference

# ══════════════════════════════════════════════════════════════════
# MOST COMMON HOOKS
# ══════════════════════════════════════════════════════════════════

# Route task to best agent
npx claude-flow@v3alpha hooks route "<task>" --include-explanation

# Start/end session with learning
npx claude-flow@v3alpha hooks session-start --start-daemon
npx claude-flow@v3alpha hooks session-end --persist-patterns

# View what the system has learned
npx claude-flow@v3alpha hooks metrics
npx claude-flow@v3alpha hooks intelligence stats

# Bootstrap on new project
npx claude-flow@v3alpha hooks pretrain --depth deep

# Dispatch background worker
npx claude-flow@v3alpha hooks worker dispatch --trigger audit

Share learned patterns across projects, teams, and the community via the decentralized pattern marketplace.

What You Can Share

Export Commands

# Export learned patterns to file
npx claude-flow@v3alpha memory export --format json --output ./patterns.json

# Export specific namespace
npx claude-flow@v3alpha memory export --namespace "security" --output ./security-patterns.json

# Export with embeddings (larger file, faster import)
npx claude-flow@v3alpha memory export --include-embeddings --output ./full-export.json

# Export agent configurations
npx claude-flow@v3alpha config export --scope project --output ./agent-configs.json

# Export session state
npx claude-flow@v3alpha session export --session-id "my-session" --output ./session.json

Import Commands

# Import patterns from file
npx claude-flow@v3alpha memory import --input ./patterns.json

# Import and merge with existing (don't overwrite)
npx claude-flow@v3alpha memory import --input ./patterns.json --merge

# Import from another project
npx claude-flow@v3alpha hooks transfer --source-path ../other-project

# Import agent configurations
npx claude-flow@v3alpha config import --input ./agent-configs.json --scope project

# Restore session
npx claude-flow@v3alpha session restore --session-id "my-session"

Pattern Store (IPFS Marketplace)

Decentralized pattern marketplace for sharing and discovering community patterns.

# Search for authentication patterns
npx claude-flow@v3alpha transfer-store search --query "authentication" --min-rating 4.0

# Download a pattern
npx claude-flow@v3alpha transfer-store download --id "auth-jwt-patterns-v2" --verify

# Publish your patterns
npx claude-flow@v3alpha transfer-store publish --input ./my-patterns.json --category "security"

Plugin Store

Discover and install community plugins.

# Search for MCP tool plugins
npx claude-flow@v3alpha transfer plugin-search --type "mcp-tool" --verified

# Get plugin info
npx claude-flow@v3alpha transfer plugin-info --name "semantic-code-search"

# List official plugins
npx claude-flow@v3alpha transfer plugin-official

IPFS Integration

Patterns are distributed via IPFS for decentralization and integrity.

# Resolve IPNS name to CID
npx claude-flow@v3alpha transfer ipfs-resolve --name "/ipns/patterns.claude-flow.io"

# Detect PII before publishing
npx claude-flow@v3alpha transfer detect-pii --content "$(cat ./patterns.json)"

Pre-Built Pattern Packs

# Install a pattern pack
npx claude-flow@v3alpha transfer-store download --id "security-essentials" --apply

The .claude/helpers/ directory contains 30+ automation scripts for development, monitoring, learning, and swarm coordination. These scripts integrate with hooks and can be called directly or via the V3 master tool.

Quick Start

# Master V3 tool - access all helpers
.claude/helpers/v3.sh help              # Show all commands
.claude/helpers/v3.sh status            # Quick development status
.claude/helpers/v3.sh update domain 3   # Update metrics

# Quick setup
.claude/helpers/quick-start.sh          # Initialize development environment
.claude/helpers/setup-mcp.sh            # Configure MCP servers

Helper Categories

📊 Progress & Metrics

🤖 Daemon & Worker Management

🧠 Learning & Intelligence

🐝 Swarm Coordination

🔒 Security & Compliance

💾 Checkpoints & Git

🎯 Guidance & Hooks

Example Workflows

Start Development Session:

# Initialize everything
.claude/helpers/v3.sh init
.claude/helpers/daemon-manager.sh start 3 5
.claude/helpers/worker-manager.sh start 60

# Check status
.claude/helpers/v3.sh full-status

Swarm Development:

# Start swarm monitoring
.claude/helpers/swarm-monitor.sh --watch &

# Initialize swarm hooks
.claude/helpers/swarm-hooks.sh init

# Monitor agent communication
.claude/helpers/swarm-comms.sh listen

Learning & Pattern Management:

# Start learning service
node .claude/helpers/learning-service.mjs &

# Consolidate patterns after session
.claude/helpers/pattern-consolidator.sh

# Optimize learned patterns
.claude/helpers/learning-optimizer.sh --aggressive

Configuration

Helpers are configured in .claude/settings.json:

{
  "helpers": {
    "directory": ".claude/helpers",
    "enabled": true,
    "v3ProgressUpdater": ".claude/helpers/update-v3-progress.sh",
    "autoStart": ["daemon-manager.sh", "worker-manager.sh"]
  }
}

Skills are reusable workflows that combine agents, hooks, and patterns into ready-to-use solutions. Think of them as "recipes" for common development tasks.

How Skills Work

┌──────────────────────────────────────────────────────────────────┐
│                         SKILL EXECUTION                          │
├──────────────────────────────────────────────────────────────────┤
│  You: "Run /github-code-review"                                  │
│           ↓                                                      │
│  ┌─────────────┐   ┌─────────────┐   ┌─────────────┐            │
│  │ Load Skill  │──▶│ Spawn Agents│──▶│ Execute     │            │
│  │ Definition  │   │ (5 agents)  │   │ Workflow    │            │
│  └─────────────┘   └─────────────┘   └─────────────┘            │
│           │                                  │                   │
│           └──── Learns from outcome ─────────┘                   │
└──────────────────────────────────────────────────────────────────┘

All 42 Skills by Category

# Example: Initialize vector search
/agentdb-vector-search

# Example: Review current PR
/github-code-review

# Example: Deploy swarm to cloud
/flow-nexus-swarm

# Example: Enable adaptive learning
/reasoningbank-intelligence

# Example: Apply security hardening
/v3-security-overhaul

# Example: Start pair programming session
/pair-programming

# Example: Run benchmarks
/worker-benchmarks

Running Skills

# In Claude Code - just use the slash command
/github-code-review
/pair-programming --mode tdd
/v3-security-overhaul

# Via CLI
npx claude-flow@v3alpha skill run github-code-review
npx claude-flow@v3alpha skill list
npx claude-flow@v3alpha skill info sparc-methodology

Creating Custom Skills

Use the skill-builder skill to create your own:

/skill-builder

Skills are defined in YAML with:

• Frontmatter: Name, description, agents needed
• Workflow: Steps to execute
• Learning: How to improve from outcomes

The Claims system manages who is working on what — whether human or agent. It prevents conflicts, enables handoffs, and balances work across your team.

Why Use Claims?

How Claims Work

┌─────────────────────────────────────────────────────────────────────┐
│                        CLAIMS LIFECYCLE                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────┐    ┌──────────┐    ┌──────────┐    ┌─────────────┐   │
│  │ UNCLAIMED│───▶│ CLAIMED  │───▶│ STEALABLE│───▶│ HANDED OFF  │   │
│  │         │    │          │    │          │    │             │   │
│  │ Open for│    │ Agent or │    │ Stuck or │    │ New owner   │   │
│  │ claiming│    │ human    │    │ abandoned│    │ continues   │   │
│  └─────────┘    └──────────┘    └──────────┘    └─────────────┘   │
│       │              │                │               │            │
│       └──────────────┴────────────────┴───────────────┘            │
│                           COMPLETED                                 │
└─────────────────────────────────────────────────────────────────────┘

Claims Commands

Visual Board View

npx claude-flow@v3alpha issues board

┌──────────────────────────────────────────────────────────────────────┐
│                        CLAIMS BOARD                                  │
├───────────────┬───────────────┬───────────────┬─────────────────────┤
│   UNCLAIMED   │    ACTIVE     │   STEALABLE   │     COMPLETED       │
├───────────────┼───────────────┼───────────────┼─────────────────────┤
│ #127 Add auth │ #123 Fix bug  │ #120 Refactor │ #119 Update docs    │
│ #128 Tests    │   (coder-1)   │   (stale 2h)  │ #118 Security fix   │
│               │ #124 API work │               │ #117 Performance    │
│               │   (reviewer)  │               │                     │
└───────────────┴───────────────┴───────────────┴─────────────────────┘

Handoff Workflow

When you need to pass work to someone else:

# 1. Request handoff with context
npx claude-flow@v3alpha issues handoff #123 \
  --to security-architect \
  --reason "Needs security review" \
  --progress 80

# 2. Target accepts handoff
npx claude-flow@v3alpha issues accept #123 --as security-architect

# 3. Work continues with full context

Load Balancing

# View current load
npx claude-flow@v3alpha issues load

# Output:
# Agent          | Claims | Load  | Status
# ---------------+--------+-------+--------
# coder-1        | 3      | 85%   | 🔴 Overloaded
# coder-2        | 1      | 25%   | 🟢 Available
# reviewer       | 2      | 50%   | 🟡 Normal
# security-arch  | 0      | 0%    | 🟢 Available

# Auto-rebalance
npx claude-flow@v3alpha issues rebalance

MCP Tools

The Route system uses Q-Learning to automatically assign tasks to the best agent based on learned performance patterns.

How Routing Works

┌─────────────────────────────────────────────────────────────────────┐
│                     INTELLIGENT ROUTING                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Task: "Fix authentication bug"                                     │
│           │                                                         │
│           ▼                                                         │
│  ┌─────────────────┐                                                │
│  │ Analyze Task    │ ← Complexity, domain, keywords                 │
│  └────────┬────────┘                                                │
│           │                                                         │
│           ▼                                                         │
│  ┌─────────────────┐                                                │
│  │ Q-Learning      │ ← Historical success rates per agent           │
│  │ Lookup          │                                                │
│  └────────┬────────┘                                                │
│           │                                                         │
│           ▼                                                         │
│  ┌─────────────────┐                                                │
│  │ Recommend:      │                                                │
│  │ security-arch   │ → 94% confidence (auth domain expert)          │
│  └─────────────────┘                                                │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Route Commands

Example: Route a Task

npx claude-flow@v3alpha route task "refactor authentication to use JWT"

# Output:
# ╔══════════════════════════════════════════════════════════════╗
# ║                    ROUTING RECOMMENDATION                     ║
# ╠══════════════════════════════════════════════════════════════╣
# ║ Task: "refactor authentication to use JWT"                    ║
# ║                                                                ║
# ║ Recommended Agent: security-architect                         ║
# ║ Confidence: 94%                                                ║
# ║                                                                ║
# ║ Why this agent?                                                ║
# ║ • Domain match: authentication, security                       ║
# ║ • Historical success: 12/13 similar tasks (92%)                ║
# ║ • Expertise: JWT, OAuth, session management                    ║
# ║                                                                ║
# ║ Alternative agents:                                            ║
# ║ • coder (78% confidence) - general implementation              ║
# ║ • backend-dev (71% confidence) - API expertise                 ║
# ╚══════════════════════════════════════════════════════════════╝

Coverage-Aware Routing

Routes tasks to agents based on test coverage gaps:

npx claude-flow@v3alpha route coverage

# Finds untested code and routes to tester agent:
# • src/auth/jwt.ts - 23% coverage → tester
# • src/api/users.ts - 45% coverage → tester
# • src/utils/crypto.ts - 0% coverage → security-architect + tester

Routing Hooks

# Route via hooks (preferred)
npx claude-flow@v3alpha hooks route "implement caching layer" --include-explanation

# Record outcome for learning
npx claude-flow@v3alpha hooks post-task --task-id "task-123" --success true --agent coder

How Q-Learning Improves Over Time

The system remembers what works and applies it to future similar tasks.

Use Claude-Flow packages directly in your TypeScript/JavaScript applications.

Installation

# Install specific packages
npm install @claude-flow/cli @claude-flow/memory @claude-flow/swarm

# Or install everything
npm install claude-flow@v3alpha

Quick Examples

import { AgentDB } from '@claude-flow/memory';

// Initialize with HNSW indexing (150x faster)
const db = new AgentDB({
  path: './data/memory',
  hnsw: { m: 16, efConstruction: 200 }
});

// Store patterns with embeddings
await db.store('auth-pattern', {
  content: 'JWT authentication flow',
  domain: 'security',
  embedding: await db.embed('JWT authentication flow')
});

// Semantic search
const results = await db.search('how to authenticate users', {
  topK: 5,
  minSimilarity: 0.7
});

console.log(results);
// [{ key: 'auth-pattern', similarity: 0.92, content: '...' }]

# Initialize memory database
npx claude-flow@alpha memory init --force

# Store patterns
npx claude-flow@alpha memory store --key "pattern-auth" --value "JWT authentication with refresh tokens"
npx claude-flow@alpha memory store --key "pattern-cache" --value "Redis caching for API responses"

# Build HNSW index for 150x-12,500x faster search
npx claude-flow@alpha memory search --query "authentication" --build-hnsw

# Semantic search (uses HNSW if built)
npx claude-flow@alpha memory search --query "how to cache data" --limit 5

# List and manage entries
npx claude-flow@alpha memory list --namespace patterns
npx claude-flow@alpha memory stats

import { createSwarm } from '@claude-flow/swarm';

// Create a hierarchical swarm
const swarm = await createSwarm({
  topology: 'hierarchical',
  maxAgents: 8,
  strategy: 'specialized'
});

// Spawn agents
await swarm.spawn('coder', { name: 'coder-1' });
await swarm.spawn('tester', { name: 'tester-1' });
await swarm.spawn('reviewer', { name: 'reviewer-1' });

// Coordinate a task
const result = await swarm.orchestrate({
  task: 'Implement user authentication',
  strategy: 'adaptive'
});

// Shutdown
await swarm.shutdown({ graceful: true });

import { isSafe, checkThreats, createAIDefence } from '@claude-flow/aidefence';

// Quick safety check
if (!isSafe(userInput)) {
  throw new Error('Potentially malicious input detected');
}

// Detailed threat analysis
const result = checkThreats(userInput);
if (!result.safe) {
  console.log('Threats:', result.threats);
  console.log('PII found:', result.piiFound);
}

// With learning enabled
const aidefence = createAIDefence({ enableLearning: true });
const analysis = await aidefence.detect(userInput);

// Provide feedback for learning
await aidefence.learnFromDetection(userInput, analysis, {
  wasAccurate: true,
  userVerdict: 'Confirmed threat'
});

import { createEmbeddingService, cosineSimilarity } from '@claude-flow/embeddings';

// Auto-selects best provider (agentic-flow ONNX preferred)
const embeddings = await createEmbeddingService({
  provider: 'auto',        // agentic-flow → transformers → mock
  autoInstall: true,       // Auto-install agentic-flow if missing
  dimensions: 384,
  cache: { enabled: true, maxSize: 10000 }
});

// Generate embeddings
const result = await embeddings.embed('authentication patterns');
console.log(`Generated in ${result.latencyMs}ms`);

// Batch processing with cache stats
const batch = await embeddings.embedBatch([
  'user login flow',
  'password reset',
  'session management'
]);
console.log(`Cache hits: ${batch.cacheStats?.hits}`);

// Compare similarity
const similarity = cosineSimilarity(batch.embeddings[0], batch.embeddings[1]);
// 0.94 (high similarity)

import { chunkText, estimateTokens } from '@claude-flow/embeddings';

const result = chunkText(longDocument, {
  maxChunkSize: 512,
  overlap: 50,
  strategy: 'sentence',  // 'character' | 'sentence' | 'paragraph' | 'token'
  minChunkSize: 100,
});

console.log(`Created ${result.totalChunks} chunks`);
result.chunks.forEach((chunk, i) => {
  console.log(`Chunk ${i}: ${chunk.length} chars, ~${chunk.tokenCount} tokens`);
});

import { l2Normalize, l1Normalize, minMaxNormalize, zScoreNormalize } from '@claude-flow/embeddings';

// L2 normalize (unit vector - most common for cosine similarity)
const l2 = l2Normalize(embedding);  // [0.6, 0.8, 0]

// Other normalizations
const l1 = l1Normalize(embedding);       // Manhattan norm = 1
const minMax = minMaxNormalize(embedding); // Values in [0, 1]
const zScore = zScoreNormalize(embedding); // Mean 0, std 1

import {
  euclideanToPoincare,
  hyperbolicDistance,
  hyperbolicCentroid,
  mobiusAdd,
} from '@claude-flow/embeddings';

// Convert to hyperbolic space (better for tree-like structures)
const poincare = euclideanToPoincare(embedding);

// Hyperbolic distance (geodesic in Poincaré ball)
const dist = hyperbolicDistance(embedding1, embedding2);

// Hyperbolic centroid (Fréchet mean)
const centroid = hyperbolicCentroid([embed1, embed2, embed3]);

// Why hyperbolic? Better for:
// - Parent-child relationships (class inheritance)
// - Directory hierarchies
// - Taxonomy structures
// - Lower distortion for tree-like data

import { createNeuralService, isNeuralAvailable } from '@claude-flow/embeddings';

// Check availability
const available = await isNeuralAvailable();

// Create neural service
const neural = createNeuralService({ dimension: 384 });
await neural.init();

if (neural.isAvailable()) {
  // Semantic drift detection (catches context drift)
  await neural.setDriftBaseline('Initial context');
  const drift = await neural.detectDrift('New input to check');
  console.log('Drift:', drift?.trend);  // 'stable' | 'drifting' | 'accelerating'

  // Memory with interference detection
  const stored = await neural.storeMemory('mem-1', 'Important pattern');
  console.log('Interference:', stored?.interference);

  // Recall by similarity
  const memories = await neural.recallMemories('query', 5);

  // Coherence calibration (fine-tune quality detection)
  await neural.calibrateCoherence(['good output 1', 'good output 2']);
  const coherence = await neural.checkCoherence('Output to verify');

  // Swarm coordination via embeddings
  await neural.addSwarmAgent('agent-1', 'researcher');
  const coordination = await neural.coordinateSwarm('Complex task');
}

import { PersistentEmbeddingCache } from '@claude-flow/embeddings';

const cache = new PersistentEmbeddingCache({
  dbPath: './embeddings.db',
  maxSize: 10000,
  ttlMs: 7 * 24 * 60 * 60 * 1000,  // 7 days
});

await cache.init();
await cache.set('my text', new Float32Array([0.1, 0.2, 0.3]));
const embedding = await cache.get('my text');

const stats = await cache.getStats();
console.log(`Hit rate: ${(stats.hitRate * 100).toFixed(1)}%`);

# Generate embedding
claude-flow embeddings embed "Your text here"

# Batch embed from file
claude-flow embeddings batch documents.txt -o embeddings.json

# Similarity search
claude-flow embeddings search "query" --index ./vectors

# Document chunking
claude-flow embeddings chunk document.txt --strategy sentence --max-size 512

# Normalize embeddings
claude-flow embeddings normalize embeddings.json --type l2 -o normalized.json

# Convert to hyperbolic
claude-flow embeddings hyperbolic embeddings.json -o poincare.json

# Neural operations
claude-flow embeddings neural drift --baseline "context" --input "check"
claude-flow embeddings neural store --id mem-1 --content "data"
claude-flow embeddings neural recall "query" --top-k 5

# Model management
claude-flow embeddings models list
claude-flow embeddings models download all-MiniLM-L6-v2

# Cache management
claude-flow embeddings cache stats
claude-flow embeddings cache clear --older-than 7d

import { HooksService } from '@claude-flow/hooks';

const hooks = new HooksService({
  enableLearning: true,
  reasoningBank: true
});

// Route task to optimal agent
const routing = await hooks.route('implement caching layer');
console.log(`Recommended: ${routing.agent} (${routing.confidence}%)`);

// Record task outcome
await hooks.postTask({
  taskId: 'task-123',
  success: true,
  quality: 0.95,
  agent: routing.agent
});

// Start trajectory for RL learning
const trajectory = await hooks.startTrajectory('complex-feature');
await hooks.recordStep(trajectory, { action: 'created service', reward: 0.8 });
await hooks.endTrajectory(trajectory, { success: true });

Package Reference

Claude-Flow v3 is built on top of agentic-flow, a production-ready AI agent orchestration platform. This deep integration provides 352x faster code transformations, learning memory, and geometric intelligence.

Quick Start

# Install globally
npm install -g agentic-flow

# Or run directly with npx
npx agentic-flow --help

# Start MCP server
npx agentic-flow mcp start

# Add to Claude Code
claude mcp add agentic-flow -- npx agentic-flow mcp start

Core Components

# Single file edit
npx agentic-flow agent-booster edit \
  --file src/api.ts \
  --instructions "Add error handling" \
  --code 'try { ... } catch (error) { ... }'

# Batch rename across codebase
npx agentic-flow agent-booster batch-rename \
  --pattern "getUserData" \
  --replacement "fetchUserProfile" \
  --glob "src/**/*.ts"

# Parse LLM markdown output
npx agentic-flow agent-booster parse-md response.md

import { ReasoningBank } from 'agentic-flow/reasoningbank';

const bank = new ReasoningBank();

// Record successful outcome
await bank.recordOutcome({
  task: 'implement authentication',
  outcome: 'JWT with refresh tokens',
  success: true,
  context: { framework: 'express' }
});

// Retrieve similar patterns for new task
const patterns = await bank.retrieveSimilar('add user login', { k: 5 });
// Returns past successful auth implementations

// Judge and distill learnings
await bank.judge(trajectoryId, 'success');
await bank.distill();  // Extract key patterns
await bank.consolidate();  // Prevent forgetting (EWC++)

import { getOptimizedEmbedder, cosineSimilarity } from 'agentic-flow/embeddings';

const embedder = getOptimizedEmbedder();
await embedder.init();

// Generate embedding (3ms local vs 230ms Transformers.js)
const vector = await embedder.embed('authentication patterns');

// Batch processing
const vectors = await embedder.embedBatch([
  'user login flow',
  'password reset',
  'session management'
]);

// Calculate similarity
const similarity = cosineSimilarity(vectors[0], vectors[1]);

import { getOptimizedEmbedder, cosineSimilarity } from 'agentic-flow/embeddings';

const embedder = getOptimizedEmbedder();
let baseline: Float32Array;

// Set baseline context
baseline = await embedder.embed('User asking about API authentication');

// Check for drift
const current = await embedder.embed(userMessage);
const drift = 1 - cosineSimilarity(baseline, current);

if (drift > 0.15) {
  console.log('Semantic drift detected - escalate');
}

// Agents coordinate via embedding positions, not messages
const agentPosition = await embedder.embed(agentRole);
const taskPosition = await embedder.embed(currentTask);

// Geometric alignment for task routing
const alignment = cosineSimilarity(agentPosition, taskPosition);

// Detect model degradation/poisoning via embedding drift
await monitor.calibrate(knownGoodOutputs);
const result = await monitor.check(newOutput);
if (result.anomalyScore > 1.5) {
  console.log('WARNING: Output drifting from baseline');
}

import { ModelRouter } from 'agentic-flow/router';

const router = new ModelRouter();

// Automatic routing based on task complexity
const result = await router.route({
  task: 'Add console.log to function',
  preferCost: true
});
// Returns: { model: 'haiku', reason: 'simple task, low complexity' }

const result2 = await router.route({
  task: 'Design distributed caching architecture'
});
// Returns: { model: 'opus', reason: 'complex architecture, high reasoning' }

# Agent Booster
npx agentic-flow agent-booster edit --file <file> --instructions "<instr>" --code '<code>'
npx agentic-flow agent-booster batch --config batch-edits.json
npx agentic-flow agent-booster batch-rename --pattern <old> --replacement <new> --glob "**/*.ts"
npx agentic-flow agent-booster parse-md response.md

# ReasoningBank
npx agentic-flow reasoningbank retrieve "query" --k 5
npx agentic-flow reasoningbank record --task "task" --outcome "outcome" --success
npx agentic-flow reasoningbank distill
npx agentic-flow reasoningbank consolidate

# Embeddings
npx agentic-flow embeddings embed "text"
npx agentic-flow embeddings batch documents.txt -o vectors.json
npx agentic-flow embeddings search "query" --index ./vectors

# Model Router
npx agentic-flow router route "task description"
npx agentic-flow router stats

# MCP Server
npx agentic-flow mcp start
npx agentic-flow mcp stdio

# Start MCP server
npx agentic-flow mcp start

# Add to Claude Code
claude mcp add agentic-flow -- npx agentic-flow mcp start

Integration with Claude-Flow

Claude-Flow automatically leverages agentic-flow for:

// Claude-Flow automatically uses agentic-flow optimizations
import { getTokenOptimizer } from '@claude-flow/integration';

const optimizer = await getTokenOptimizer();

// Uses ReasoningBank (32% fewer tokens)
const ctx = await optimizer.getCompactContext('auth patterns');

// Uses Agent Booster (352x faster edits)
await optimizer.optimizedEdit(file, old, new, 'typescript');

// Uses Model Router (optimal model selection)
const config = optimizer.getOptimalConfig(agentCount);

Agentic-Jujutsu is quantum-ready, self-learning version control designed for multiple AI agents working simultaneously without conflicts. Built on Jujutsu, it provides 23x faster performance than Git with automatic conflict resolution.

Quick Start

# Install globally (zero dependencies - jj binary embedded!)
npm install -g agentic-jujutsu

# Or run directly with npx
npx agentic-jujutsu --help

# Analyze repository for AI agent compatibility
npx agentic-jujutsu analyze

# Start MCP server for AI agents
npx agentic-jujutsu mcp-server

# Compare performance with Git
npx agentic-jujutsu compare-git

Why Agentic-Jujutsu?

Core Capabilities

const { JjWrapper } = require('agentic-jujutsu');

const jj = new JjWrapper();

// Start learning trajectory
const trajectoryId = jj.startTrajectory('Deploy to production');

// Perform operations (automatically tracked)
await jj.branchCreate('release/v1.0');
await jj.newCommit('Release v1.0');

// Record operations to trajectory
jj.addToTrajectory();

// Finalize with success score (0.0-1.0) and critique
jj.finalizeTrajectory(0.95, 'Deployment successful, no issues');

// Later: Get AI-powered suggestions for similar tasks
const suggestion = JSON.parse(jj.getSuggestion('Deploy to staging'));
console.log('AI Recommendation:', suggestion.reasoning);
console.log('Confidence:', (suggestion.confidence * 100).toFixed(1) + '%');

// All agents work concurrently (no conflicts!)
const agents = ['researcher', 'coder', 'tester'];

const results = await Promise.all(agents.map(async (agentName) => {
    const jj = new JjWrapper();

    // Start tracking
    jj.startTrajectory(`${agentName}: Feature implementation`);

    // Get AI suggestion based on learned patterns
    const suggestion = JSON.parse(jj.getSuggestion(`${agentName} task`));

    // Execute task (no lock waiting!)
    await jj.newCommit(`Changes by ${agentName}`);

    // Record learning
    jj.addToTrajectory();
    jj.finalizeTrajectory(0.9);

    return { agent: agentName, success: true };
}));

console.log('All agents completed:', results);

const { generateQuantumFingerprint, verifyQuantumFingerprint } = require('agentic-jujutsu');

// Generate SHA3-512 fingerprint (NIST FIPS 202)
const data = Buffer.from('commit-data');
const fingerprint = generateQuantumFingerprint(data);
console.log('Fingerprint:', fingerprint.toString('hex'));

// Verify integrity (<1ms)
const isValid = verifyQuantumFingerprint(data, fingerprint);
console.log('Valid:', isValid);

// HQC-128 encryption for trajectories
const crypto = require('crypto');
const jj = new JjWrapper();
const key = crypto.randomBytes(32).toString('base64');
jj.enableEncryption(key);

Claude-Flow Skill

Claude-Flow includes a dedicated /agentic-jujutsu skill for AI-powered version control:

# Invoke the skill
/agentic-jujutsu

Use this skill when you need:

• ✅ Multiple AI agents modifying code simultaneously
• ✅ Lock-free version control (23x faster than Git)
• ✅ Self-learning AI that improves from experience
• ✅ Quantum-resistant security for future-proof protection
• ✅ Automatic conflict resolution (87% success rate)
• ✅ Pattern recognition and intelligent suggestions

MCP Tools for AI Agents

# Start the MCP server
npx agentic-jujutsu mcp-server

# List available tools
npx agentic-jujutsu mcp-tools

# Call a tool from your agent
npx agentic-jujutsu mcp-call jj_status

Available MCP Tools:

CLI Commands Reference

# Repository Operations
npx agentic-jujutsu status          # Show working copy status
npx agentic-jujutsu log --limit 10  # Show commit history
npx agentic-jujutsu diff            # Show changes
npx agentic-jujutsu new "message"   # Create new commit

# AI Agent Operations
npx agentic-jujutsu analyze         # Analyze repo for AI compatibility
npx agentic-jujutsu ast "command"   # Convert to AI-readable AST format
npx agentic-jujutsu mcp-server      # Start MCP server
npx agentic-jujutsu mcp-tools       # List MCP tools

# Performance
npx agentic-jujutsu bench           # Run benchmarks
npx agentic-jujutsu compare-git     # Compare with Git

# Info
npx agentic-jujutsu help            # Show all commands
npx agentic-jujutsu version         # Show version info
npx agentic-jujutsu examples        # Show usage examples

Version Evolution

RuVector is a high-performance distributed vector database combining vector search, graph queries, and self-learning neural networks. Written in Rust with Node.js/WASM bindings, it powers Claude-Flow's intelligence layer with native speed.

Key Capabilities

Performance Benchmarks

Quick Start

# Install ruvector (auto-detects native vs WASM)
npm install ruvector

# Or run directly
npx ruvector --help

# Start Postgres for centralized coordination
docker run -d -p 5432:5432 ruvnet/ruvector-postgres

Basic Usage

import ruvector from 'ruvector';

// Initialize vector database
const db = new ruvector.VectorDB(384); // 384 dimensions

// Insert vectors
await db.insert('doc1', embedding1);
await db.insert('doc2', embedding2);

// Search (returns top-k similar)
const results = await db.search(queryEmbedding, 10);

// Graph queries with Cypher
await db.execute("CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})");
const friends = await db.execute("MATCH (p:Person)-[:KNOWS]->(friend) RETURN friend.name");

// GNN-enhanced search (self-learning)
const layer = new ruvector.GNNLayer(384, 256, 4);
const enhanced = layer.forward(query, neighbors, weights);

// Compression (2-32x memory reduction)
const compressed = ruvector.compress(embedding, 0.3); // 30% quality threshold

Package Ecosystem

🐘 RuVector PostgreSQL — Enterprise Vector Database

77+ SQL functions for AI operations directly in PostgreSQL with ~61µs search latency and 16,400 QPS.

# Quick setup with CLI (recommended)
npx claude-flow ruvector setup --output ./my-ruvector
cd my-ruvector && docker-compose up -d

# Or pull directly from Docker Hub
docker run -d \
  --name ruvector-postgres \
  -p 5432:5432 \
  -e POSTGRES_USER=claude \
  -e POSTGRES_PASSWORD=claude-flow-test \
  -e POSTGRES_DB=claude_flow \
  ruvnet/ruvector-postgres

# Migrate existing memory to PostgreSQL
npx claude-flow ruvector import --input memory-export.json

RuVector PostgreSQL vs pgvector:

Key SQL Functions:

-- Vector operations with HNSW indexing
SELECT * FROM embeddings ORDER BY embedding <=> query_vec LIMIT 10;

-- Hyperbolic embeddings for hierarchical data
SELECT ruvector_poincare_distance(a, b, -1.0) AS distance;
SELECT ruvector_mobius_add(a, b, -1.0) AS result;

-- Cosine similarity
SELECT cosine_similarity_arr(a, b) AS similarity;

Benefits over Local SQLite:

import { FlashAttention } from '@ruvector/attention';

const attention = new FlashAttention({
  blockSize: 32,      // L1 cache optimized
  dimensions: 384,
  temperature: 1.0,
  useCPUOptimizations: true
});

// Compute attention with O(N) memory instead of O(N²)
const result = attention.attention(queries, keys, values);
console.log(`Computed in ${result.computeTimeMs}ms`);

// Benchmark against naive implementation
const bench = attention.benchmark(512, 384, 5);
console.log(`Speedup: ${bench.speedup}x`);
console.log(`Memory reduction: ${bench.memoryReduction}x`);

import { SONA } from '@ruvector/sona';

const sona = new SONA({
  enableLoRA: true,       // Low-rank adaptation
  enableEWC: true,        // Elastic Weight Consolidation
  learningRate: 0.001
});

// Start learning trajectory
const trajectory = sona.startTrajectory('task-123');

// Record steps during execution
trajectory.recordStep({
  type: 'observation',
  content: 'Found authentication bug'
});
trajectory.recordStep({
  type: 'action',
  content: 'Applied JWT validation fix'
});

// Complete trajectory with verdict
await trajectory.complete('success');

// EWC++ consolidation (prevents forgetting)
await sona.consolidate();

import { GraphDB } from '@ruvector/graph-node';

const db = new GraphDB({ path: './data/graph' });

// Create nodes and relationships
await db.query(`
  CREATE (a:Agent {name: 'coder', type: 'specialist'})
  CREATE (b:Agent {name: 'reviewer', type: 'specialist'})
  CREATE (a)-[:COLLABORATES_WITH {weight: 0.9}]->(b)
`);

// Query patterns
const result = await db.query(`
  MATCH (a:Agent)-[r:COLLABORATES_WITH]->(b:Agent)
  WHERE r.weight > 0.8
  RETURN a.name, b.name, r.weight
`);

// Hypergraph support for multi-agent coordination
await db.createHyperedge(['agent-1', 'agent-2', 'agent-3'], {
  type: 'consensus',
  topic: 'architecture-decision'
});

Integration with Claude-Flow

Claude-Flow automatically uses RuVector when available:

// Claude-Flow detects and uses native ruvector
import { getVectorStore } from '@claude-flow/memory';

const store = await getVectorStore();
// Uses ruvector if installed, falls back to sql.js

// HNSW-indexed search (150x faster)
const results = await store.search(queryVector, 10);

// Flash Attention for pattern matching
const attention = await getFlashAttention();
const similarity = attention.attention(queries, keys, values);

CLI Commands

# RuVector PostgreSQL Setup (generates Docker files + SQL)
npx claude-flow ruvector setup                    # Output to ./ruvector-postgres
npx claude-flow ruvector setup --output ./mydir   # Custom directory
npx claude-flow ruvector setup --print            # Preview files

# Import from sql.js/JSON to PostgreSQL
npx claude-flow ruvector import --input data.json              # Direct import
npx claude-flow ruvector import --input data.json --output sql # Dry-run (generate SQL)

# Other RuVector commands
npx claude-flow ruvector status --verbose         # Check connection
npx claude-flow ruvector benchmark --vectors 10000 # Performance test
npx claude-flow ruvector optimize --analyze       # Optimization suggestions
npx claude-flow ruvector backup --output backup.sql # Backup data

# Native ruvector CLI
npx ruvector status                               # Check installation
npx ruvector benchmark --vectors 10000 --dimensions 384

Generated Setup Files:

ruvector-postgres/
├── docker-compose.yml    # Docker services (PostgreSQL + pgAdmin)
├── README.md             # Quick start guide
└── scripts/
    └── init-db.sql       # Database initialization (tables, indexes, functions)

Flow Nexus is a cloud platform for deploying and scaling Claude-Flow beyond your local machine.

What Flow Nexus Provides

Core Capabilities

┌─────────────────────────────────────────────────────────────────────┐
│                      FLOW NEXUS PLATFORM                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                 │
│  │   Swarm     │  │   Neural    │  │  Sandboxes  │                 │
│  │   Cloud     │  │   Training  │  │   (E2B)     │                 │
│  │             │  │             │  │             │                 │
│  │ Scale to    │  │ Distributed │  │ Isolated    │                 │
│  │ 100+ agents │  │ GPU training│  │ code exec   │                 │
│  └─────────────┘  └─────────────┘  └─────────────┘                 │
│                                                                     │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                 │
│  │   App       │  │  Workflows  │  │ Challenges  │                 │
│  │   Store     │  │  (Events)   │  │ & Rewards   │                 │
│  │             │  │             │  │             │                 │
│  │ Publish &   │  │ Event-driven│  │ Gamified    │                 │
│  │ discover    │  │ automation  │  │ learning    │                 │
│  └─────────────┘  └─────────────┘  └─────────────┘                 │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Skills for Flow Nexus

Cloud Swarm Deployment

# Deploy swarm to Flow Nexus cloud
/flow-nexus-swarm

# Or via CLI
npx claude-flow@v3alpha nexus swarm deploy \
  --topology hierarchical \
  --max-agents 50 \
  --region us-east-1

E2B Sandboxes

Isolated execution environments for running untrusted code:

# Create sandbox
npx claude-flow@v3alpha nexus sandbox create --language python

# Execute code safely
npx claude-flow@v3alpha nexus sandbox exec --code "print('Hello')"

# Cleanup
npx claude-flow@v3alpha nexus sandbox destroy

Event-Driven Workflows

# workflow.yaml
name: code-review-pipeline
triggers:
  - event: pull_request.opened
steps:
  - action: spawn_swarm
    config:
      topology: mesh
      agents: [reviewer, security-architect, tester]
  - action: run_review
  - action: post_comments
  - action: shutdown_swarm

Getting Started with Flow Nexus

# 1. Sign up at flow-nexus.io
# 2. Get API key
# 3. Configure
npx claude-flow@v3alpha nexus configure --api-key <key>

# 4. Deploy
npx claude-flow@v3alpha nexus swarm deploy

Stream-Chain enables sequential processing where the output of one agent becomes the input of the next.

Pipeline Concept

┌─────────────────────────────────────────────────────────────────────┐
│                     STREAM-CHAIN PIPELINE                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Input ──▶ [Agent 1] ──▶ [Agent 2] ──▶ [Agent 3] ──▶ Output        │
│            (Research)    (Implement)   (Test)                       │
│                                                                     │
│  Each stage transforms and passes data to the next                  │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Creating Pipelines

# Via skill
/stream-chain

# Define pipeline
npx claude-flow@v3alpha stream-chain create \
  --name "feature-pipeline" \
  --stages "researcher,architect,coder,tester,reviewer"

Pipeline Definition (YAML)

name: feature-development
description: End-to-end feature implementation

stages:
  - name: research
    agent: researcher
    input: requirements
    output: analysis

  - name: design
    agent: architect
    input: analysis
    output: architecture

  - name: implement
    agent: coder
    input: architecture
    output: code

  - name: test
    agent: tester
    input: code
    output: test_results

  - name: review
    agent: reviewer
    input: [code, test_results]
    output: final_review

Running Pipelines

# Run the pipeline
npx claude-flow@v3alpha stream-chain run feature-pipeline \
  --input '{"requirements": "Add user dashboard with analytics"}'

# Monitor progress
npx claude-flow@v3alpha stream-chain status feature-pipeline

Use Cases

The Pair Programming skill provides human-AI collaborative coding with role switching, TDD support, and real-time verification.

Modes

Starting a Session

# Start pair programming
/pair-programming

# Or with specific mode
/pair-programming --mode tdd

# Via CLI
npx claude-flow@v3alpha pair start --mode navigator

TDD Mode Workflow

┌─────────────────────────────────────────────────────────────────────┐
│                     TDD PAIR PROGRAMMING                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  1. Human writes failing test                                       │
│           ↓                                                         │
│  2. AI implements minimal code to pass                              │
│           ↓                                                         │
│  3. Tests run automatically                                         │
│           ↓                                                         │
│  4. AI suggests refactoring                                         │
│           ↓                                                         │
│  5. Human approves/modifies                                         │
│           ↓                                                         │
│  6. Repeat                                                          │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Features

Session Commands

# Switch roles mid-session
npx claude-flow@v3alpha pair switch

# Get AI explanation
npx claude-flow@v3alpha pair explain

# Run tests
npx claude-flow@v3alpha pair test

# End session with summary
npx claude-flow@v3alpha pair end

AI Manipulation Defense System (AIMDS) — Protect AI applications from prompt injection, jailbreaks, and data exposure with sub-millisecond detection.

Detection Time: 0.04ms | 50+ Patterns | Self-Learning | HNSW Vector Search

Why AIDefence?