# claude-flow [Health: Active]

**Category:** 🤖 Coding Agents  
**Repository:** https://github.com/ruvnet/claude-flow  
**GitHub Stars:** 79183  
**npm Downloads (last month):** 222378  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/claude-flow

## Description
AI orchestration with hive-mind swarms, neural networks, and 87 MCP tools for enterprise dev.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "claude-flow": {
    "command": "npx",
    "args": ["-y","ruflo@latest"]
  }
}
```

## Documentation

## What claude-flow does

claude-flow is the earlier name and lineage of Ruflo, an agent meta-harness built around Claude Code and Codex. It places an orchestration layer between an AI coding client and the agents that perform work, providing task routing, swarm coordination, memory, scheduling, and execution controls.

The system is intended for projects where one model session is not enough to manage the work. Agents can be organized into coordinated swarms, while stored experience can be reused across sessions. Federation extends coordination to agents on other machines, with security guardrails intended for controlled enterprise environments.

## How it works

The conceptual flow is the client or CLI, followed by Ruflo’s router, swarm, agents, memory layer, and configured language-model providers. Ruflo uses the MCP interface to make its orchestration functions available to an MCP-compatible client. The server runs locally through a stdio process rather than requiring a hosted MCP endpoint.

Ruflo can also operate through Claude Code plugins. The core plugin supplies foundational tools, the console provides an agent cockpit, and the mods package adds routing and policy enforcement inside Claude Code. The optional terminal UI can run independently of Claude Code and displays project, cost, swarm, event, and mission information.

Memory and learning features include local vector retrieval and trajectory-based feedback mechanisms. Local retrieval and contrastive updates can run without an LLM, although embeddings and configured learning components are still needed for those workflows.

## Setup and configuration

For a standard MCP client, initialize Ruflo in the project directory with:

```bash
npx ruflo@latest init wizard
```

Configure the client with `npx` as the command and `[-y, ruflo@latest, mcp, start]` as its arguments. The equivalent command is:

```bash
npx -y ruflo@latest mcp start
```

Claude Code users can instead add the Ruflo marketplace and install the core, console, and mods plugins, then reload plugins and launch the Ruflo interface. The documented Claude Code path requires Claude Code 2.1.287 or later. Mods execute with the permissions of the user account, so their code should be reviewed before installation.

An optional standalone terminal interface is available with `npx ruflo tui`; adding `--plain` prints one frame for script-oriented use.

## Tools and capabilities

The MCP surface provides access to capabilities including:

- Agent and swarm coordination
- Task routing and scheduling
- Persistent memory and local vector retrieval
- Inter-agent communication and federation
- Execution monitoring through the console or terminal UI
- Policy enforcement and runtime routing in Claude Code
- Learning from task outcomes and successful patterns

After initialization, the hooks system can route tasks, reuse learned patterns, and coordinate agents while the developer continues to work through Claude Code normally.

## Limitations and notes

Ruflo’s console and mods are Claude Code integrations; MCP support alone does not provide those plugin-specific features. Hook behavior depends on the client. Federation is intended for communication between machines and should be evaluated alongside the project’s security requirements.

The server exposes a broad tool surface, but users do not need to learn every tool to begin. The standard entry point is the initialization wizard followed by normal use through the configured MCP client. Agent execution may still require an LLM even when local retrieval or contrastive learning runs locally.

_Full upstream README: https://allmcps.com/mcp/claude-flow/readme_