Ruflo: Multi-Agent Orchestration for Claude Code with 56k+ GitHub Stars
Ruflo has crossed 56,000 GitHub stars and 6,400 forks, establishing itself as the leading multi-agent orchestration platform for Claude Code. Originally launched as Claude Flow, Ruflo rebranded in January 2026 and has shipped 1,488 releases with an intense alpha cycle every few days. The project solves a critical gap: Claude Code is a single-agent tool, but teams need coordinated swarms of specialized agents that share memory, run across machines, and respect trust boundaries.
What is Ruflo?
Ruflo is an open-source orchestration layer that transforms Claude Code from a single-agent tool into a multi-agent platform. Created by rUv and maintained by a 20-person contributor team, Ruflo enables teams to deploy 100+ specialized agents that coordinate via hierarchical, mesh, or adaptive topologies. The project is 87.4% TypeScript with Rust, Svelte, and shell components, reflecting a production-grade engineering approach.
The core insight behind Ruflo is that modern development teams don't need one powerful agent—they need many focused agents that know what each other has already done. A coder agent, a test agent, a security agent, and a documentation agent working in isolation produce fragmented results. Ruflo's shared memory layer (AgentDB) and federation model ensure agents coordinate seamlessly, even across organizational boundaries.
The project has evolved significantly since its Claude Flow origins. The rebranding to Ruflo in early 2026 coincided with the introduction of the three-runtime model: local WASM sandboxes for offline work, Claude Agent SDK for in-process execution, and Anthropic Managed Agents for cloud deployments. All three runtimes share a unified interface, giving teams deployment flexibility without architectural rework.
Core Features and Architecture
Multi-Agent Swarms with Shared Memory
Ruflo's swarm coordination layer supports three topology patterns: hierarchical (tree-based delegation), mesh (peer-to-peer coordination), and adaptive (topology shifts based on task complexity). Agents coordinate via Raft, Byzantine, or Gossip consensus algorithms. The critical differentiator is AgentDB, a vector database with HNSW indexing that delivers sub-millisecond memory retrieval. Agents query shared context—previous decisions, learned patterns, tool results—without re-computing or re-discovering information.
Three Agent Runtimes
Ruflo abstracts three deployment targets behind a single tool interface:
- Local WASM Sandbox: Agents run offline in a WebAssembly container, ideal for untrusted code or air-gapped environments. No external API calls required.
- Claude Agent SDK (In-Process): Agents execute within the same Node.js process, enabling rapid prototyping and tight integration with local tools.
- Anthropic Managed Agents (Cloud): Production workloads run in Anthropic's managed containers with automatic scaling, audit logging, and compliance features.
This abstraction is rare. Most multi-agent frameworks lock you into one deployment model. Ruflo's three-runtime approach means you can prototype locally, test in-process, and scale to cloud without rewriting agent definitions.
Zero-Trust Federation
Agents on different machines authenticate via mTLS and ed25519 signatures. A 14-type PII detection pipeline automatically strips sensitive data before it crosses trust boundaries. Trust scores update continuously based on agent behavior, creating a behavioral security model rather than a static allowlist. This is the architecture required when AI work crosses company lines—platform teams coordinating with product teams, or agencies working with clients.
311 MCP Tools with Zero Dangling References
Ruflo registers 311 Model Context Protocol tools, each verified by CI to have no orphaned definitions. This is an engineering signal most tool-heavy projects lack. The tools wrap Anthropic's Managed Agents REST API, enabling agents to spawn sub-agents, manage long-running tasks, and coordinate across the three runtimes.
32 Claude Code Plugins
Plugins handle swarm coordination, RAG memory, security auditing, cost tracking, and more. Teams install via `/plugin install ruflo-core@ruflo` and adopt capabilities incrementally. The plugin marketplace approach reduces adoption friction—you don't have to adopt the entire system at once.
Self-Learning via SONA
Ruflo's SONA (Self-Optimizing Neural Architecture) layer persists successful patterns across sessions. The ReasoningBank stores trajectories and retrieves them via HNSW search, enabling agents to learn from past runs. Whether this changes agent behavior in practice is an open question—the project ships the infrastructure, but real-world benchmarks on learning impact are limited.
Cryptographic Verification Pipeline
Every release ships with Ed25519-signed manifests and witness proofs. The `ruflo verify` command lets users confirm installed bytes match the signed manifest. This is rare for open-source projects at this scale and reflects a security-first engineering culture.
Get free AI agent insights weekly
Join our community of builders exploring the latest in AI agents, frameworks, and automation tools.
Getting Started
Prerequisites: Node.js 18+, Claude Code installed, and an Anthropic API key.
Installation:
npx ruflo@latest initThis command scaffolds a `.claude-plugin` directory, initializes AgentDB, and registers the 311 MCP tools. The init process detects your platform (macOS, Linux, Windows) and deploys platform-specific hooks.
Basic Agent Definition:
// agents/coder.agent.ts
import { Agent, Tool } from '@claude-flow/core';
const coderAgent = new Agent({
name: 'coder',
model: 'claude-3-5-sonnet-20241022',
systemPrompt: 'You are an expert software engineer. Write clean, tested code.',
tools: [
Tool.fileRead(),
Tool.fileWrite(),
Tool.executeCommand(),
],
maxTurns: 12,
});
export default coderAgent;Spawning a Swarm:
import { Swarm } from '@claude-flow/swarm';
import coderAgent from './agents/coder.agent';
import testerAgent from './agents/tester.agent';
import securityAgent from './agents/security.agent';
const swarm = new Swarm({
agents: [coderAgent, testerAgent, securityAgent],
topology: 'hierarchical',
coordinator: coderAgent, // coder delegates to tester and security
});
const result = await swarm.execute({
task: 'Refactor the auth service and ensure it passes security tests',
context: { repo: 'auth-service', branch: 'main' },
});The swarm executes with shared memory. The coder agent's file writes are visible to the tester agent. The security agent's vulnerability findings are visible to both. No agent re-discovers what another has already done.
Real-World Use Cases
Platform Teams Coordinating Across Microservices
A platform team maintains 12 microservices across three repos. They install Ruflo in each repo and connect them via federation: `npx claude-flow@latest federation join wss://team-hub.internal:8443`. When a developer asks Claude Code to refactor the auth service, Ruflo spawns a swarm: coder handles implementation, tester generates tests via the `ruflo-testgen` plugin, security runs vulnerability scans via `ruflo-security-audit`. The federation layer detects that the auth contract changed and flags breaking consumers in the API gateway repo. PII from test data stays stripped from cross-repo messages.
Compliance-Heavy Organizations
Financial services and healthcare teams need audit trails, PII stripping, and behavioral trust scoring. Ruflo's zero-trust federation model handles this natively. Agents authenticate via mTLS, sensitive data is automatically redacted, and every agent action is logged with cryptographic signatures. The `ruflo verify` command lets compliance teams confirm that deployed agents match signed manifests.
Agencies and Consulting Firms
Agencies working with multiple clients need agent isolation and trust boundaries. Ruflo's federation model enables client-specific agent swarms that coordinate with agency infrastructure without exposing client data. Each client's agents run in a separate trust domain with behavioral trust scoring that prevents data leakage.
Research and Benchmarking
Ruflo ships with GAIA (General AI Agent Benchmark) integration. The project includes agents that solve complex research questions, with support for multi-attempt voting, adversarial critic review, question decomposition, and causal failure memory. Teams can benchmark agent performance across different models, topologies, and strategies without building custom evaluation infrastructure.
How It Compares
vs. LangGraph
LangGraph is a library for building agent workflows in Python. You define state machines, write custom logic, and deploy to your infrastructure. Ruflo is a platform with plugins, federation, and managed runtimes. LangGraph gives you more control; Ruflo gives you more infrastructure. For teams building custom agent logic, LangGraph is the right choice. For teams adopting Claude Code and needing coordination, Ruflo is the right choice.
vs. AutoGen
AutoGen (Microsoft) focuses on multi-agent conversation patterns and role-playing. Agents take turns speaking, and the framework manages the conversation loop. Ruflo focuses on task coordination and shared memory. AutoGen is better for conversational multi-agent scenarios; Ruflo is better for task-oriented swarms that need to coordinate across machines and trust boundaries.
vs. Claude Code Alone
Claude Code is a single-agent tool. It's excellent for one developer on one repo. It breaks when you have teams, multiple repos, or compliance requirements. Ruflo adds coordination, shared memory, federation, and audit trails. The trade is simplicity for scale. A solo developer doesn't need Ruflo. A team running Claude Code across multiple services with compliance requirements gets real value.
What's Next
Ruflo's roadmap reflects the intensity of the project. Recent releases (alpha.27 to alpha.33) shipped security hooks, witness verification, and managed agent runtimes. The project is actively working on:
- GAIA Benchmark Integration: Real-world agent evaluation with multi-attempt voting, critic review, and decomposition strategies. The goal is to beat human performance on complex research questions.
- Causal Failure Memory: Agents record why they failed and retrieve those causal edges on future runs. This is one of Ruflo's six architectural primitives that competing frameworks lack.
- Hardness Routing: Predict question difficulty and allocate compute accordingly. Easy questions route to Haiku (cheap), hard questions route to Sonnet with voting (expensive but accurate).
- Cross-Org Federation: Extend federation beyond teams to enable agencies and consulting firms to coordinate agents across client boundaries with behavioral trust scoring.
The 1,488 releases shipped to date suggest a project that's found its shape and is now optimizing it. The three-runtime abstraction, the federation model, and the cryptographic verification pipeline are the architectural choices that will define Ruflo's future. Whether teams actually adopt federation at scale—coordinating agents across orgs—will determine whether Ruflo becomes infrastructure or stays an internal coordination tool.