Ruflo Is Claude Flow: What Actually Changed

If you bookmarked github.com/ruvnet/claude-flow sometime in the last year, that URL now redirects to a repo called Ruflo. Same maintainer, same 7,394 commits, same roughly 69,000 stars. The rename is real and it is finished on the repo side, but it is nowhere near finished everywhere else, and that gap is where people are losing an afternoon.

The short version: Claude Flow is now Ruflo. The README says so in a collapsed section titled "where the name comes from," attributing the choice to the maintainer rUv. What the README does not say clearly is that the old name is still load-bearing in at least four places you will touch during a normal install.

Key Takeaways:

• Claude Flow renamed to Ruflo; the GitHub redirect works and both npm names publish identical builds.
• The old name survives in the @claude-flow/* scope, the .claude-flow/ project directory, and several README commands.
• The plugin path writes zero files; npx ruflo init writes three paths plus hooks and a daemon.
• Versions 3.38.17 and 3.38.18 are deprecated after a publish race corrupted the dependency graph. Pin exact versions.

What Ruflo is, once you get past the name

The project describes itself as an agent meta-harness for Claude Code and Codex. Strip the marketing and it is an orchestration layer that sits above a coding agent: it adds a router, a swarm coordinator, persistent memory across sessions, a hooks system that intercepts your Claude Code activity, and a daemon that keeps the whole arrangement running. The README's own framing is worth quoting because it is unusually honest about the division of labour: "Agent = Model + Harness. The model writes; the harness gives it tools, memory, loops, sandboxes, and controls so it can actually work."

The scale claims are large. The CLI track advertises 98 agents, 60-plus commands, 30 skills, and an MCP server. Elsewhere the README reassures newcomers that they "don't need to learn 314 MCP tools or 26 CLI commands," which is a strange sentence to need to write, and a decent signal of how much surface area is in there.

Ruflo vs Claude Flow: which name wins where

Here is the map, verified against the registry and the repo on 22 August 2026.

The GitHub repo is ruvnet/ruflo. The old path 301-redirects, so old links keep working and old clones keep fetching.

The npm packages are two, not one. ruflo and claude-flow both exist, both are current, and both published version 3.38.19 on the same day. The ruflo package is not new either; its first alpha went up on 16 February 2026, months before the repo itself changed name. So neither name is deprecated, and picking either one gets you the same bits.

The scoped packages kept the old name entirely. You will install @claude-flow/mcp, @claude-flow/memory, and @claude-flow/codex. There is no @ruflo/* scope.

The directory the CLI writes into your project is .claude-flow/. Not .ruflo/. If you are grepping your own repo six months from now wondering what put a .claude-flow folder there, this paragraph is the answer.

And the docs still run the old command. The federation walkthrough in the README, which is one of the more interesting parts of the project, tells you to type npx claude-flow@latest federation init. That is in the current README, under the current name.

None of this is broken, exactly. It is just a project that renamed its front door and left the plumbing labelled.

Two install paths that are not variations of each other

The README puts these side by side in a table, and the difference matters more than the table's calm tone suggests.

The Claude Code plugin path adds slash commands and agent definitions through the marketplace: /plugin marketplace add ruvnet/ruflo, then /plugin install ruflo-core@ruflo and whichever of the 35 plugins you want. Files written to your workspace: zero. Hooks installed: none. Only ruflo-core registers an MCP server, and its tools come through namespaced as mcp__plugin_ruflo-core_ruflo__memory_store rather than the bare memory_store the CLI docs assume, which is a small detail that will waste your time if you follow a CLI tutorial while on the plugin track.

The CLI path is npx ruflo init, and it is the one the documentation is written for. It writes .claude/, .claude-flow/, and a CLAUDE.md into your workspace, installs hooks, registers the MCP server, and starts a daemon. The README calls this "production use — everything works as documented." Which is another way of saying the lite path is not fully documented.

Pick the plugin path to look around. Pick the CLI path if you actually want the swarm behaviour, and pick somewhere other than your working repo to run it the first time, because it is not a small footprint. A throwaway cloud box is the cheapest version of that: on MoClaw you get a machine that is already provisioned, so the .claude-flow/ directory and the hooks land somewhere you can delete without thinking about it, instead of in the repo you have to ship from on Monday.

The daemon is the part nobody plans for

A hooks system and a background daemon change what your laptop is for. The whole premise is that agents self-organise, learn from completed tasks, and keep memory across sessions; the federation layer goes further and lets agents on different machines discover each other over mTLS with ed25519 challenge-response, exchange work, and build up trust levels over time.

All of that assumes something is running. A swarm that coordinates 98 agent definitions and a learning loop is not a thing you want competing with your build for CPU, and a federation node that is only reachable while your lid is open is not really a node. That is the specific gap MoClaw fills: a hosted cloud AI computer that stays awake, so the daemon has somewhere to live that isn't the machine you also use for everything else. It sits alongside your local install rather than replacing it.

Pin your version, and here's the receipt

The project ships fast. Four releases went out on 21 August 2026 and two more the next day; back on 29 July there were ten in a single day. Fast is fine. What you should read before you npx ruflo@latest anything is the v3.38.19 release note, which supersedes v3.38.17 and v3.38.18 because both "shipped with a corrupted dependency graph due to a publish race between two concurrent sessions working this checkout simultaneously." Those two versions are now deprecated on npm for all three packages.

That is a candid postmortem and I would rather have it than silence. It is also a direct argument for pinning an exact version in anything you care about, and for reading the release title before upgrading. The v3.38.19 notes go on to describe a doctor check that reports whether the active SQLite driver is the native better-sqlite3 or the sql.js fallback, the latter of which, in the maintainer's own words, "silently drops writes." Run that check.

What it actually plugs into

The native targets are Claude Code and Codex, with Hermes and others named in the repo's own description. The @claude-flow/codex package is the Codex side. Local models come in through the ruflo-ruvllm plugin with routing, and there are separate plugins for vector memory (ruflo-agentdb, ruflo-ruvector), knowledge graphs, browser automation via Playwright, test generation, and documentation.

Worth being precise here: This project is not integrated with MoClaw, and nothing in this article should be read as saying it is. The overlap is conceptual. It solves coordination between agents; the question of what hardware those agents run on is separate, and it is the one people answer badly by defaulting to their own laptop. A hosted machine that isn't yours means the memory store and the hooks survive a reboot you didn't plan.

Who this is for, honestly

Not everyone running Claude Code needs a coordination layer above it. If your work is one repo, one session at a time, and you have never once wished a second agent were reviewing while the first one wrote, then 35 plugins and a background router is overhead you will feel and benefit you will not.

The install starts paying for itself at the point where you are already doing coordination by hand: two terminals, a scratch file where you paste context between sessions, a mental note about which agent knows what. That is the workload the swarm model is aimed at, and the persistent memory across sessions is the feature that actually removes work rather than adding a menu.

There is a second threshold underneath the first one, and it gets skipped. Coordination that runs in the background needs a machine that is on in the background. Anyone who has watched a long agent run die because a laptop slept through it already knows the failure mode; the run doesn't error, it just stops existing. MoClaw is a hosted cloud AI computer, so an overnight swarm keeps going after you shut the lid, and the memory it built is still there in the morning. That's a hardware answer to a hardware problem, not a replacement for the orchestration layer on top.

Where a meta-harness stops helping

Two honest limits.

First, the surface area is the product. 314 MCP tools and 35 plugins is not a thing you evaluate in an afternoon, and the README's "just use Claude Code normally, the hooks handle it" pitch is doing a lot of work. Hooks that route your tasks in the background are excellent when they route correctly and confusing when they don't, and debugging a background router is harder than debugging a command you typed.

Second, the project is one maintainer's architecture, tightly coupled to an ecosystem the same author built: Cognitum.One for the engine, RuVector for the database, flo.ruv.io for the UI beta. That coupling is why the pieces fit together well. It is also concentration risk, and 561 open issues against 270 open pull requests is what an ambitious project moving at this speed looks like from the outside.

If you are running Ruflo across more than one machine, federation is the feature to look at, and it is also the point where "which machine is always on" stops being a philosophical question. Keeping one node hosted rather than nominating someone's laptop as the permanent coordinator is the arrangement that survives contact with a weekend.

FAQ

Is Ruflo the same project as Claude Flow?

Yes. ruvnet/claude-flow redirects to ruvnet/ruflo, and the README states the rename directly. The npm package claude-flow is still published and still current; it now carries the description "Ruflo — Enterprise AI agent orchestration."

Which npm package should I install, ruflo or claude-flow?

Either resolves to the same version. Use ruflo for anything new, since that is the name the docs and the CLI use. Keep in mind that the scoped dependencies are still @claude-flow/* and the project directory it creates is still .claude-flow/.

Is it free and open source?

The repository is MIT-licensed, confirmed on the repo as of August 2026. The surrounding ecosystem, including the Cognitum.One engine and the hosted UI beta, is a separate question the licence file does not answer.

Is Ruflo the same thing as DeepSeek Harness?

No, and the distinction is the point of the "meta" prefix. A harness gives one model its tools, memory, and control loop. This one sits a layer above and coordinates several of those, which is why it lists Claude Code and Codex as targets rather than competitors. If the layering is unfamiliar, what an agent harness actually is covers the tier below, and Swarm Forge covers a different take on the coordination tier.

Do I need the daemon running for Ruflo to do anything?

For the plugin path, no; you get slash commands and nothing in the background. For the CLI path, the daemon and hooks are the mechanism, so the answer is effectively yes, which is worth knowing before you install it on a laptop you close at six.

What breaks if I already had claude-flow installed?

Nothing, based on the current state of the registry. Both package names publish the same builds, the repo redirect handles old remotes, and the .claude-flow/ directory was never renamed. The one thing to fix is any pin to 3.38.17 or 3.38.18, both of which are deprecated. If you are running several agents in parallel and want the general shape of that problem, parallel agents in Claude Code is the adjacent read.