claude-agent-orchestration

Key Features • Architecture • Agent Swarm • Quick Start • MCP Tools • LLM Providers • Docs

---

📌 Overview

Claude-Flow V3 (claude-agent-orchestration) is an enterprise-grade, Domain-Driven Design (DDD) multi-agent coordination engine built for autonomous development swarms. It orchestrates collaborative AI agents using Hierarchical-Mesh topologies, Model Context Protocol (MCP) native tool dispatch, AgentDB HNSW vector indexing, and Flash-Attention accelerated inter-agent messaging.

Whether executing complex code refactors, multi-stage TDD verification pipelines, distributed security audits, or full-stack software generation, Claude-Flow coordinates specialized agents with sub-millisecond dispatch and deterministic rollback guarantees.

🚀 Key Features

🏛️ Architecture Overview

graph TD
    User["👤 Developer / MCP Client / CLI"] -->|JSON-RPC / Direct TS| Orchestrator["👑 Unified Swarm Coordinator (Queen)"]
    
    subgraph "Coordination & Topology"
        Orchestrator --> SecurityDomain["🛡️ Security Domain (Agents 2-4)"]
        Orchestrator --> CoreDomain["⚙️ Core Systems (Agents 1, 5-9)"]
        Orchestrator --> IntegrationDomain["🔗 Integration & Neural (Agents 10-12)"]
        Orchestrator --> QualityDomain["🧪 Quality & Performance (Agents 13-15)"]
    end

    subgraph "Application Engine"
        CoreDomain --> WorkflowEngine["📋 DAG Workflow Engine"]
        WorkflowEngine --> TaskExecutor["⚡ Topological Task Dispatcher"]
    end

    subgraph "Persistence & Memory"
        TaskExecutor --> HybridMemory["💾 Hybrid Memory Layer"]
        HybridMemory --> SQLite["🗄️ SQLite (Relational State)"]
        HybridMemory --> AgentDB["🔍 AgentDB (HNSW Vector Index)"]
    end

    subgraph "Infrastructure & Extensibility"
        Orchestrator --> MCPServer["📡 MCP Protocol Server"]
        Orchestrator --> PluginManager["🧩 Microkernel Plugin Manager"]
    end

📊 Performance Benchmarks

🐝 15-Agent Swarm Matrix

The V3 swarm architecture distributes responsibility across 6 domain tiers:

                  ┌───────────────────────────────┐
                  │    Agent 1: Queen Coordinator │
                  └───────────────┬───────────────┘
          ┌───────────────────────┼───────────────────────┐
          │                       │                       │
┌─────────▼──────────┐ ┌──────────▼──────────┐ ┌──────────▼──────────┐
│  Security Domain   │ │    Core Domain      │ │ Integration Domain │
│  (Agents 2, 3, 4)  │ │ (Agents 5, 6, 7, 8) │ │ (Agents 10, 11, 12)│
└────────────────────┘ └─────────────────────┘ └─────────────────────┘
          │                       │                       │
          └───────────────────────┼───────────────────────┘
                                  │
                       ┌──────────▼──────────┐
                       │   Support Domain    │
                       │ (Agents 13, 14, 15) │
                       └─────────────────────┘

📦 Quick Start

1. Installation

# Install globally
npm install -g claude-flow

# Or add to your existing TypeScript/Node.js project
npm install claude-flow

2. Command Line Interface (CLI)

# Display system health and environment diagnostics
claude-flow doctor

# Initialize a swarm with hierarchical topology
claude-flow swarm init --topology hierarchical

# Spawn a specialized agent
claude-flow agent spawn --id coder-1 --type coder

# Start full orchestrator & MCP stdio server
claude-flow start

3. Programmatic TypeScript API

import { 
  initializeV3Swarm, 
  WorkflowEngine, 
  HybridBackend,
  SQLiteBackend,
  AgentDBBackend
} from 'claude-flow';

// 1. Initialize Hybrid Memory Backend (SQLite + AgentDB Vector Index)
const sqlite = new SQLiteBackend();
const agentdb = new AgentDBBackend();
const memory = new HybridBackend(sqlite, agentdb);
await memory.initialize();

// 2. Initialize Swarm Coordinator with Mesh Topology
const swarm = await initializeV3Swarm({
  topology: 'mesh',
  memoryBackend: memory,
  maxAgents: 10
});

// 3. Spawn Specialized Agents
const coder = await swarm.spawnAgent({
  id: 'agent-coder-1',
  type: 'coder',
  capabilities: ['code', 'refactor', 'debug']
});

const tester = await swarm.spawnAgent({
  id: 'agent-tester-1',
  type: 'tester',
  capabilities: ['test', 'validate']
});

// 4. Execute a DAG Workflow with Auto-Rollback
const workflowEngine = new WorkflowEngine({ coordinator: swarm, memoryBackend: memory });
await workflowEngine.initialize();

const result = await workflowEngine.executeWorkflow({
  id: 'wf-feature-build',
  name: 'Feature Implementation Workflow',
  rollbackOnFailure: true,
  tasks: [
    {
      id: 'task-1',
      type: 'code',
      description: 'Generate user authentication module',
      priority: 'high',
      onExecute: async () => { /* Code generation logic */ },
      onRollback: async () => { /* Clean up files on error */ }
    },
    {
      id: 'task-2',
      type: 'test',
      description: 'Run unit test suite against auth module',
      priority: 'medium',
      dependencies: ['task-1'],
      onExecute: async () => { /* Run test suites */ }
    }
  ]
});

console.log(`Workflow Status: ${result.status}, Completed: ${result.tasksCompleted}`);

📡 MCP Server & Tools

Claude-Flow V3 acts as a native Model Context Protocol (MCP) server, making your swarm tools accessible to Claude Desktop, Cursor, VSCode, and other AI IDEs:

{
  "mcpServers": {
    "claude-flow": {
      "command": "npx",
      "args": ["claude-flow", "start"]
    }
  }
}

Registered MCP Tools

🤖 LLM Provider Matrix & Pricing

Claude-Flow supports multi-provider routing with load balancing, latency tracking, and automatic failover:

📁 Repository Structure

claude-agent-orchestration/
├── v3/
│   ├── src/                               # Core Domain-Driven Design Layer
│   │   ├── agent-lifecycle/domain/        # Agent entity & lifecycle management
│   │   ├── coordination/application/      # SwarmCoordinator & topology routing
│   │   ├── task-execution/
│   │   │   ├── domain/                    # Task entity & DAG topological sorting
│   │   │   └── application/               # WorkflowEngine with rollback support
│   │   ├── memory/
│   │   │   ├── domain/                    # MemoryEntity & search abstractions
│   │   │   └── infrastructure/            # SQLiteBackend, AgentDBBackend, HybridBackend
│   │   ├── infrastructure/
│   │   │   ├── mcp/                       # MCPServer & Tool Providers (Agent, Memory, Config)
│   │   │   └── plugins/                   # BasePlugin, ExtensionPoints, PluginManager
│   │   ├── shared/types/                  # Canonical type definitions & error classes
│   │   └── index.ts                       # Core module barrel export
│   ├── @claude-flow/                      # Standalone Monorepo Packages
│   │   ├── cli/                           # CLI binary & MCP Stdio bridge
│   │   ├── swarm/                         # Swarm topologies, Raft/Byzantine consensus
│   │   ├── memory/                        # Vector index services & caching
│   │   └── shared/                        # EventBus & Event-Sourcing projections
│   ├── __tests__/                         # Vitest London-School Integration Test Suite
│   ├── swarm.config.ts                    # 15-Agent Swarm Declarative Configuration
│   └── index.ts                           # Top-level V3 entry point
├── package.json                           # Root ESM configuration & dependencies
├── tsconfig.json                          # TypeScript ES2022 / ESNext configuration
└── README.md                              # Project documentation

🧪 Testing

Claude-Flow follows the London School TDD (Mock-First) methodology with 100% isolated test suites:

# Run all unit and integration tests
npm test

# Run tests with interactive browser UI
npm run test:ui

# Run security audit & penetration verification suites
npm run security:test

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'feat: Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📈 Star History

📄 License

Distributed under the MIT License. See LICENSE for more information.