Ruflo: Multi-Agent Orchestration for Claude Code That Actually Scales

Why Ruflo Is Everywhere Right Now

ruvnet/ruflo cracked the top of GitHub trending this week with roughly 35,900 stars, a number that tells you something real is happening here. The project - formerly called Claude Flow before a rename that signals both a Rust-native rewrite and a broader ambition - positions itself as the orchestration layer Claude Code was always missing: a way to run not one Claude agent but hundreds of them, coordinating across machines, teams, and organizational boundaries in real time.

The timing matters. Claude Code skills and hooks have matured quickly, and a certain class of builder has hit the ceiling of what a single Claude Code session can do. Ruflo is aimed directly at that ceiling. It does not replace Claude Code; it extends it into a distributed system with its own memory, routing intelligence, background workers, and federation layer.

What Ruflo Does

At its core, Ruflo is an orchestration platform that coordinates 100+ specialized AI agents on top of Claude (and other providers). The headline capability is swarm coordination: agents can be arranged into hierarchical, mesh, or adaptive topologies, with a consensus mechanism deciding how tasks fan out and results flow back.

The memory layer is where Ruflo distinguishes itself most technically. Rather than losing context between agent runs, it ships AgentDB - a vector store backed by HNSW indexing that the project claims delivers sub-millisecond retrieval. The improvement over brute-force search is cited at 150x to 12,500x depending on dataset size. Whether those numbers hold in production varies by workload, but the architecture - embedding-based storage with approximate nearest-neighbor search - is sound.

On top of memory, Ruflo adds SONA - a self-learning layer that updates agent behavior based on trajectory outcomes. Agents get better at routing tasks over time instead of making the same mistakes across sessions.

The platform also ships 27 integration hooks that slot directly into the Claude Code event lifecycle, 12 background workers that fire automatically for audit, optimization, and testing tasks, and a federation layer for cross-installation collaboration secured with mTLS and ed25519 signatures. For teams running Claude Code across multiple machines or org boundaries, the federation piece alone is worth examining.

Security gets genuine attention. There is a CVE scanning pipeline, a prompt injection blocker, and a PII detection layer that classifies 14 data types and redacts based on federation trust level. A behavioral trust scoring formula evaluates peers continuously across success rate, uptime, threat history, and integrity factors.

The plugin ecosystem spans 32 native Claude Code plugins across categories: core orchestration, memory, intelligence, quality, security, architecture, DevOps, and domain-specific extensions.

Install and Try It

The fastest path is the Claude Code plugin approach. Inside an active Claude Code session:

/plugin marketplace add ruvnet/ruflo
/plugin install ruflo-core@ruflo
/plugin install ruflo-swarm@ruflo

For the federation layer, add:

/plugin install ruflo-federation@ruflo

If you prefer the CLI route:

npm install -g ruflo@latest
npx ruflo@latest init --wizard

Or the shell installer:

curl -fsSL https://cdn.jsdelivr.net/gh/ruvnet/ruflo@main/scripts/install.sh | bash

For MCP server mode, which wires Ruflo into Claude as a tool provider:

claude mcp add ruflo -- npx -y @claude-flow/cli@latest

Two hosted web interfaces are available without any local install: flo.ruv.io runs a multi-model chat with parallel MCP tool execution, and goal.ruv.io exposes a Goal-Oriented Action Planning interface where you describe an objective in plain English and GOAP with A* search decomposes it into an executable action plan.

Who Should Use This

Ruflo is built for a specific type of builder - one who has already hit the limits of single-session Claude Code work and wants to move toward something closer to an autonomous pipeline.

If you are running overnight agent loops (the kind where one parent agent fans out 5 to 10 subagents per cycle), Ruflo's swarm coordination and background workers address the coordination overhead that makes those loops fragile. Instead of hand-rolling a task router and hoping the planner stays coherent across context resets, you get a structured layer that handles routing with claimed 89% accuracy.

Teams running Claude Code across multiple engineers or machines get the federation layer, which handles the cross-installation trust and communication problem that currently requires custom glue code or shared secrets passed around in Slack.

Security-conscious shops will appreciate the PII redaction and prompt injection blocking, particularly if agents are touching production data or calling external APIs.

This is not a beginner project. The setup involves certificates for federation, Docker and MongoDB for self-hosted web UIs, and a 32-plugin ecosystem that takes real time to understand. If you are still at the "write one good system prompt" stage of AI tooling, come back after you have run a few multi-agent loops manually and hit the coordination pain yourself.

How This Connects to the DevDigest Ecosystem

Ruflo lands directly in the territory that Developers Digest covers every week. The hooks system - 27 integration points into the Claude Code lifecycle - is exactly what the hooks reference at hooks.developersdigest.tech catalogs and explains. If you have been reading about Claude Code hooks but wondering how they compose at scale, Ruflo is a concrete example of building an entire orchestration layer on top of them.

The MCP server mode connects to the broader MCP landscape covered at mcp.developersdigest.tech. Adding Ruflo as an MCP server means your Claude instance gains 100+ agent tools as callable functions - a meaningful step up from individual MCP servers that expose one service at a time.

The skills architecture also mirrors what the community built at skills.developersdigest.tech: composable, installable behaviors that extend what Claude Code can do without touching core prompts. Ruflo's plugin model is a heavier version of the same idea, trading simplicity for enterprise-grade coordination.

The federation layer is the most forward-looking piece. As more teams move to ambient AI infrastructure - agents running continuously across machines rather than in single sessions on a developer's laptop - cross-installation trust becomes a solved-problem-or-not that determines whether multi-team agent workflows are feasible. Ruflo is one of the first open-source projects to tackle it directly.

Honest Assessment

The ambition here is real and the architecture is coherent. HNSW vector memory, SONA self-learning, and zero-trust federation are not vaporware patterns - they are established techniques applied carefully to a novel domain. The plugin ecosystem breadth (32 plugins, 27 hooks) suggests sustained development rather than a weekend project.

The limitations are also real. The performance numbers - 150x to 12,500x faster search, 89% routing accuracy - come from the project's own documentation and have not been independently validated. The federation setup requires certificate management that will trip up engineers who have not operated mTLS infrastructure before. PII redaction that varies by trust level needs calibration or it will produce false positives that break workflows. And the background workers cap at 12, which may not be enough for large-scale distributed scenarios.

The rename from Claude Flow to Ruflo happened recently and the codebase still references @claude-flow/cli in some install commands - a sign that the project is mid-transition in ways that could affect stability. Watch the issue tracker before building a production dependency on it.

For builders who want to experiment: start with flo.ruv.io before installing anything. If the multi-agent execution model resonates, graduate to the Claude Code plugin install. Leave federation for after you have validated the core swarm behavior in your own workflows.

References

• Ruflo repository: https://github.com/ruvnet/ruflo
• Ruflo web UI (no install): https://flo.ruv.io
• Goal planner: https://goal.ruv.io
• Ruflo plugin marketplace: https://ruvnet.github.io/ruflo
• Developers Digest hooks reference: https://hooks.developersdigest.tech
• Developers Digest MCP directory: https://mcp.developersdigest.tech
• Developers Digest skills directory: https://skills.developersdigest.tech
• GitHub trending - daily: https://github.com/trending?since=daily
• GitHub trending - weekly: https://github.com/trending?since=weekly