RuFlow Review: What a Claude Agent Swarm Really Does

In short

RuFlow is what most people type when they mean Ruflo — the MIT-licensed orchestration project by Reuven Cohen that used to be called Claude Flow. It sits on top of Claude Code and turns a single agent into a coordinated swarm: a planner, a coder, a tester and a reviewer working in parallel against a shared vector memory, with steps routed across several model providers. Install is one command on Node 20 or newer. As of July 2026 the npm package ruflo is at 3.32.25 and the GitHub repo sits around 66k stars, with releases landing almost daily.

It earns its place when work splits into parallel tracks and you want memory that survives between sessions. It does not earn it on a single feature branch — Claude Code's built-in subagents cover that. Two things to know first: the viral "75% cheaper API bill" figure is not in the official README, and an independent audit of v3.5.51 found most advertised MCP tools did nothing while adding 15,000–25,000 tokens of overhead per session.

What RuFlow is trying to solve

A single coding agent is a queue. It plans, then it writes, then it runs tests, then it reviews its own diff — one step at a time, in one context window, and it forgets most of that context the moment you start a new session. Two failure modes follow. The long task blows the context budget halfway through and the agent starts guessing at code it read forty minutes ago. And the decision you made on Tuesday ("we don't use the ORM in the billing module") has to be re-explained on Thursday.

Ruflo's answer is a harness. The pitch on the repo is blunt: "Agent = Model + Harness. The model writes; the harness gives it tools, memory, loops, sandboxes, and controls." Instead of one agent doing five jobs sequentially, you get several agents doing one job each, concurrently, writing what they learn into a shared store that the next session can query.

That framing matters because it tells you what Ruflo is not. It is not a model, not an IDE, and not a replacement for Claude Code. It is plumbing around Claude Code, and its value is entirely a function of whether your workload actually needs plumbing.

How the swarm is organised

Three moving parts do the real work.

Topology. Agents are arranged hierarchically (a coordinator — the docs call it a "queen" — hands work down to specialists), as a mesh where every worker talks to every other worker, or adaptively. Hierarchical is the sane default. Mesh gets expensive fast: every additional worker multiplies the cross-talk, and cross-talk is tokens. If you take one configuration decision seriously, take this one.

Memory. A vector store with HNSW indexing holds what agents learn, so decisions and patterns survive session boundaries. This is the part of Ruflo that independent testers consistently confirm works. The self-learning layer on top (marketed as SONA neural patterns) is harder to verify — Augment Code's write-up on Ruflo flagged exactly this, noting there are no real benchmarks showing that the learning loop changes agent behaviour.

Routing. Tasks get spread across Claude, GPT, Gemini, Cohere and Ollama with failover, the idea being that cheap steps go to cheap models. Mechanically this is real and it is the most defensible cost argument the project has.

Around that sit roughly 35 plugins, background workers, a federation layer with mTLS and PII stripping, and a beta web UI at flo.ruv.io you can poke at without installing.

Setting it up

There are two install routes and they are not the same product, which trips people up constantly.

The full route writes into your project and gives you everything — agents, hooks, background daemon, MCP server:

npx ruflo@latest init wizard

The light route lives entirely inside Claude Code as a plugin, gives you slash commands only, and leaves your repo alone:

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

If you want the MCP server without the wizard's file dump, wire it up directly the same way you'd add any other server (see our walkthrough on connecting an MCP server to Claude Code):

claude mcp add ruflo -- npx ruflo@latest mcp start

Start with the plugin. Run it for a week on real tasks. Only move to init wizard if you hit something the slash commands can't do — the full install drops .claude/, .claude-flow/, a CLAUDE.md and assorted helpers into your tree, and unpicking that later is annoying.

When many agents beat one

The pattern in that table: Anthropic has closed most of the gap Ruflo originally filled. Subagents and agent teams shipped natively, and they are the boring correct answer for the majority of tasks. What remains genuinely Ruflo's is cross-session memory and provider routing. If neither of those is your bottleneck, you are installing 300-plus tool definitions to solve a problem you don't have.

Where the approach falls apart

In April 2026 a developer published a hands-on audit of ruflo v3.5.51 that is worth reading in full before you commit. The headline findings:

• Of the ~300 advertised MCP tools, roughly 10 did real work. Agent spawn returned JSON records without launching a subprocess. Swarm coordination reported agentCount: 0 despite registered agents. Neural training returned randomised accuracy figures.
• Tool definitions alone added an estimated 15,000–25,000 tokens per session, while the project advertised a 30–50% token reduction. The auditor found no token-counting code in the tree at all.
• The auto-memory graph had ballooned to 100 MB containing 5,706 entries of which about 20 were unique.
• What did work: HNSW vector search, AgentDB pattern storage, terminal session persistence, the auto-memory hook.

Two caveats in fairness to the project. That audit is one person's methodology on one version, and it is now several months and many releases old — the current npm release is 3.32.25, and the maintainers have shipped memory-graph deduplication since. But nobody has published a comparable audit showing the theatre was fixed, either. Treat the feature list as marketing until you've measured your own session.

The release cadence cuts both ways too. Well over a thousand releases means bugs get fixed fast and it also means a tutorial from six months ago is probably lying to you about command names.

What it actually costs

Nothing, and quite a lot.

Ruflo itself is free and MIT-licensed — no subscription, no account, no key. The tokens come out of your existing Claude plan or API key, and a swarm burns them in parallel by design. Ten agents working simultaneously is ten context windows being filled simultaneously. On a Max plan you'll hit rate limits sooner; on pay-as-you-go the bill moves.

The "75% API cost reduction" figure that circulates on X and DEV is not in the current official README. The savings mechanism is real — routing trivial steps to Ollama or a cheap API model instead of a frontier model does cost less — but the percentage is entirely workload-dependent. Measure it. Ruflo ships a cost-tracker plugin for exactly this, and if you want a baseline to compare against, our breakdown of what vibe coding actually costs per month has real numbers.

One practical guardrail: set a spend cap before your first swarm run. The failure mode people describe isn't a slow leak, it's one overnight run against a mesh topology.

FAQ

Is RuFlow the same thing as Ruflo or Claude Flow?

Yes — one project, three spellings. It launched as Claude Flow, was renamed Ruflo in early 2026, and "RuFlow" is the community spelling that stuck in search and social posts. The npm package is ruflo, the repo is ruvnet/ruflo, and searching for "Claude Flow" will still surface old docs with outdated command names. Our RuFlow tool card tracks the current install commands.

Does RuFlow really cut Claude API costs by 75%?

Unverified. The number comes from social media, not the official README, and the April 2026 audit found no token-accounting code in the project to substantiate any percentage. The underlying mechanism — routing simple steps to cheaper or local models — genuinely reduces spend, but by how much depends entirely on what fraction of your work is trivial. Run the cost-tracker plugin for a week before believing any figure, including this one.

Do I need RuFlow if Claude Code already has subagents?

Usually not. Subagents give you isolated context windows, scoped tool permissions and cost control via cheaper models, natively and with zero install. Agent teams cover multi-agent sessions where the agents need to communicate. What RuFlow adds beyond that is memory persisting across sessions and routing across non-Anthropic providers. If those two aren't your bottleneck, stay native.

How do I try RuFlow without polluting my repo?

Use the Claude Code plugin route (/plugin marketplace add ruvnet/ruflo, then /plugin install ruflo-core@ruflo). It adds slash commands and nothing else — no .claude-flow/ directory, no hooks, no background daemon. You lose the full swarm, but you get a realistic feel for whether the workflow suits you. The web UI at flo.ruv.io is an even lower-commitment look, with no install and no key.

Is RuFlow safe to run on a client codebase?

Treat it like any third-party harness with filesystem access and shell tools: run it in a container or a scratch clone first. It's MIT-licensed and the source is readable, but the full install adds background processes and hooks that intercept your agent's tool calls, and the release cadence means the code you audited last month isn't the code running today. The federation layer does strip PII from inter-agent messages, but that's a feature for multi-machine setups, not a substitute for scoping what the agent can touch.