Ruflo ships v3.10 agent orchestration for Claude Code: why graph intelligence is the move worth watching

Personalized PageRank. Dynamic mincut. Spectral sparsification. These are not phrases I expected to see in the release notes of a Claude Code plugin.

That's what shipped in Ruflo v3.10: six pathfinder algorithms borrowed from graph theory, applied to the problem of figuring out which agent should do what. The maintainer's argument is that multi-agent coordination becomes a graph problem once you have enough agents in play. Memory pools and better prompts only get you so far.

What Happened

ruvnet/ruflo has 55.4K stars and 6.3K forks, with 23 contributors and has shipped 1,494 releases. Version 3.10.2 landed yesterday and includes a Windows-compatible Node shim plus an init-time platform check (issue #2132). The codebase is 86.5% TypeScript, with Svelte, Rust, and shell making up the rest.

What I'd flag from the repo state:

• The v3.10 line ships ADR-130 phases 4 through 6: a plugin adapter that bridges graph data to plugins, six pathfinder algorithms (personalized PageRank, dynamic mincut, spectral sparsification, temporal centrality, connected-component churn, witness-chain divergence), and a benchmark suite. Three npm packages stay version-locked: @claude-flow/cli@3.10.x, claude-flow@3.10.x, and ruflo@3.10.x.
• The release cadence is intense. 1,494 releases is the kind of number you only get from a maintainer who treats version bumps as a development tool. Recent commits include CVE patches, shell injection fixes, and SSRF remediation (#2114), suggesting that security is being treated as a feature rather than an afterthought.
• The project rebranded from Claude Flow to Ruflo with v3.5.0 in February 2026. The rebrand is still incomplete in places: package names, federation plugin paths, and some commit messages still reference claude-flow.
• Commits co-authored with @claude show up regularly. The maintainer is dogfooding the orchestration layer on the orchestration layer.

Key Features

• Graph intelligence with six pathfinder algorithms: personalized PageRank, dynamic mincut, spectral sparsification, temporal centrality, connected-component churn, and witness-chain divergence. This is the v3.10 line's headline feature, and it lets the orchestrator reason about agent state as a graph rather than as a flat memory pool.
• Multi-agent swarm coordination: hierarchical, mesh, and adaptive topologies with Raft, Byzantine, and Gossip consensus. HNSW-indexed vector memory in AgentDB hits 2,345 ops/sec write throughput and 4.9ms p99 latency on depth-1 k-hop queries, per the project's own benchmarks.
• Self-learning via SONA: neural pattern matching and trajectory learning persist across sessions. The ReasoningBank stores successful patterns for later retrieval. Whether this actually changes agent behavior in practice is something I'd want to see independent benchmarks on.
• Zero-trust agent federation: agents on different machines authenticate via mTLS and ed25519, with PII stripped before any data leaves a node. Trust scores adjust dynamically. The project ships with HIPAA, SOC 2, and GDPR compliance modes for audit trails.
• 33 native Claude Code plugins: orchestration, memory, security, and testing, plus domain-specific plugins for IoT device management and algorithmic trading. Install via /plugin install ruflo-core@ruflo.
• Multi-provider routing: Claude, GPT, Gemini, Cohere, and Ollama with automatic failover. Teams that don't want to lock to one vendor get optionality without rebuilding their agent layer.

Why It Matters

A few patterns I'm seeing more broadly line up with this:

• Graph intelligence is the next abstraction layer. Most multi-agent frameworks treat agent state as a key-value memory pool. Once you have dozens of agents working in parallel, that flat model breaks down. Reasoning about state as a graph (which agent touched which file, which task blocks which other task) is the architecture that scales.
• Single-agent Claude Code is hitting a coordination wall. Sessions are isolated, memory doesn't persist, and there's no native way to coordinate work across agents. Ruflo's traction shows that teams are willing to adopt a coordination layer rather than wait for Anthropic to ship one.
• Federation is the part that matters at the org level. Most multi-agent frameworks assume one trust domain. Ruflo's federation handles agents across machines, teams, and orgs with mTLS, PII stripping, and behavioral trust scoring. That's the architecture you need when AI work crosses company lines.

The graph intelligence pieces are the design choice I'd flag for anyone evaluating this. If pathfinding through state space actually changes how agents coordinate, this is a meaningful step. If it stays a benchmark feature, it's interesting but not foundational.

Example Use Case

A platform team wants to ship an auth refactor with tests and a pull request. An engineer opens Ruflo's Goal Planner at goal.ruv.io and types the goal in plain English.

The GOAP A* planner extracts the success criteria, the constraints, and the implicit preconditions, then searches through actions to find the shortest viable path. Ruflo dispatches the work to specialized agents (coder, tester, reviewer) running as a swarm. The agents share context through AgentDB. The coder writes the TypeScript changes; the tester generates vitest specs against the new code.

When the test agent hits a failure, the planner reruns A* from the current state rather than restarting. The graph intelligence layer then identifies which other agents are affected by the failure (witness-chain divergence) and reroutes work. Results flow back into memory, so future refactoring tasks start with knowledge of what worked. Live agent status shows up at goal.ruv.io/agents.

This is the workflow I'd demo to platform teams that have already adopted Claude Code and are now hitting the "my agents don't know what your agents are doing" problem.

Competitive Context

A few things stand out when you put Ruflo next to the obvious alternatives:

• LangGraph and CrewAI require Python agent graphs: Ruflo targets the Claude Code ecosystem directly via MCP tools and plugins. The tradeoff: tight coupling to Anthropic's tooling in exchange for zero-config integration. For teams already deep in Claude Code, the trade favors Ruflo.
• The published benchmarks are aggressive: The v3.8.0 SOTA matrix claims cold-start and single-turn performance advantages of 1.3× to 1,953× over LangGraph, AutoGen, and CrewAI on darwin-arm64 and linux-x64. These are the project's own benchmarks. I'd want independent reproduction before treating them as gospel, but the spread is wide enough to be worth verifying.
• The plugin marketplace is the moat: 33 native Claude Code plugins plus 21 npm plugins is a larger ecosystem than most multi-agent frameworks have built. The marketplace approach lets teams adopt one capability at a time rather than adopting the entire system.

The trade is simplicity for scale. A solo developer working on one repo doesn't need swarm consensus, federation, or graph pathfinding. A team running Claude Code across multiple services with compliance requirements gets real value from the trust model, audit trails, and cross-agent memory.

My Take

What I keep coming back to: 1,494 releases is either a sign of a healthy, fast-moving project or a sign of a project that hasn't found its shape yet. The CI verification pipeline, the ADR process, and the security patching cadence suggest the former. But you're adopting a moving target. Version 3.10.2 shipped yesterday. Version 3.11 is probably weeks away.

The graph intelligence work in v3.10 is the part I'd watch most closely. If pathfinder algorithms actually change how agents coordinate at scale, this is the architectural bet that pays off. If it stays a benchmark feature, Ruflo remains a swarm-plus-memory tool with extra metadata.

I'm also curious whether the published benchmarks hold up to independent reproduction. A 1,953× speedup over CrewAI is the kind of number that either reveals a real architectural advantage or reveals a benchmark designed to flatter the home team. The raw matrix JSON is in the repo, so the answer is testable. The web UI beta at flo.ruv.io is the easiest way to kick the tires without committing to a full install.