Ruflo: Turning One Coding Agent Into a Swarm

Ruflo is an orchestration layer that sits on top of a coding agent you already use and turns it into a coordinated swarm — many specialised agents working the same codebase, sharing a vector memory, reachable through an MCP server. It does not replace your agent. It amplifies it.

Its thesis fits on a line: Agent = Model + Harness. Ruflo is betting the harness is where the remaining gains are.

Key takeaways

• A meta-harness, not a framework rewrite. It orchestrates the agent you already run rather than asking you to adopt a new one.
• Over a hundred specialised agents across coding, testing, security, documentation and architecture, plus a large plugin catalogue.
• Shared vector memory with an HNSW index, so agents in a swarm work against common context instead of re-deriving it.
• Swarm topologies — hierarchical, mesh, adaptive — plus background workers that audit, test and optimise on their own.
• A security layer aimed at prompt injection and PII, which is unusual and welcome in this category.
• Huge surface area, a very large open issue count, and a rename that left package names out of sync with the docs. Pilot before you commit.

What problem is it attacking?

One agent is one context window doing one thing. That is fine for an hour. It is not fine for a fortnight.

Anyone who has run a long agentic session knows the shape of the failure. Quality is excellent early, drifts around the middle, and by the time the window is full the agent is confidently contradicting decisions it made an hour ago. There is no way to run a security reviewer, a test author and an implementer concurrently against the same codebase while they all know what the others found.

The single-agent answer is to start a fresh session and re-explain. Ruflo's answer is to decompose the work across specialists who share memory, so no single context window has to hold the whole project.

How does Ruflo work?

The pipeline runs from your command through a router into a swarm, out to individual agents, against a shared memory, and down to whichever model providers you have configured. Agent trajectories feed back into memory, which is the learning loop.

• Swarm topologies. Hierarchical for a supervisor-and-workers shape, mesh for peers, adaptive to let it choose. The topology is the thing you tune when coordination, rather than capability, is the bottleneck.
• Vector memory with HNSW. Approximate nearest neighbour search rather than comparing every vector — the same technique behind most production vector databases, applied to agent memory.
• MCP server. Your coding agent talks to Ruflo as a tool provider, which is why adopting it does not mean abandoning your current setup. The protocol is covered in our MCP guide.
• Background workers. A set of auto-triggered workers handle auditing, testing and optimisation without being asked.
• Federation. Agent memory can be shared across installations with zero-trust security and PII redaction — the feature that maps most directly onto a multi-developer agency.

Getting started

There are two install paths with genuinely different surface areas, so pick one deliberately. The wizard is the gentler entry:

npx ruflo@latest init wizard

Or register it as an MCP server against your existing agent:

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

Note the old name still appearing in that command. That is the rename showing through, and it is the kind of friction to expect across the documentation.

Reading the benchmark claims honestly

Ruflo publishes comparisons against the established orchestration frameworks claiming wins on cold-start latency and memory efficiency of between 1.3 times and 1953 times.

A range spanning three orders of magnitude is not a result; it is several different results averaged into one headline. The 1.3 figure is probably a fair like-for-like comparison. The 1953 figure is probably a case where the competing framework does something Ruflo skips entirely. Both may be true and neither tells you what your workload will do.

This is not an accusation of bad faith — self-published benchmarks are normal, and the vector memory claims are stated far more carefully. It is a reminder to benchmark on your own repository before you plan around a number someone else measured.

Alternatives worth knowing

• Your agent's built-in subagents — the most underrated option. Claude Code and others already fan out work to sub-agents. It is free, already installed, and covers a surprising amount of what people reach for a swarm framework to do. Start here and find the actual limit before adding a layer.
• LangGraph — more rigorous, Python-first, with an explicit graph you can reason about and test. Less batteries-included, more predictable. The better choice when the orchestration itself needs to be auditable.
• CrewAI — role-based crews with a simple mental model. Easiest of the group to explain to a team.
• AutoGen — conversation-driven multi-agent from Microsoft, with a research pedigree and reasonable docs.

What to be careful about

• Surface area is the risk. A hundred agents and dozens of plugins is a lot of code to trust. Enable what you need, not the catalogue.
• The open issue count is very large, and the patch cadence is high. Pin versions and read release notes.
• Naming is inconsistent post-rename. Expect the package, the CLI and the docs to disagree occasionally.
• Swarms multiply cost. Ten agents on a task is roughly ten times the tokens. Sometimes that is a bargain; sometimes it is a very expensive way to get the same answer. Measure.
• Parallel agents on one repository need conflict discipline. Decide up front whether they work in separate branches or worktrees.

Conclusion

Ruflo is one of the most ambitious things in this series, and one of the ones to approach most carefully. The core insight — that the harness matters as much as the model — is correct and increasingly obvious. The implementation is enormous, fast-moving and self-benchmarked.

Our honest recommendation: exhaust your agent's native sub-agent support first. If you hit a real wall — genuinely needing shared memory across parallel specialists — then Ruflo is worth a serious pilot on internal work.

Want AI in your delivery process without the chaos?

DI Solutions helps teams work out which parts of their .NET and React delivery genuinely benefit from agents, and which are faster done by a person. Talk to our engineers before you buy the biggest framework on the shelf.

Reference links

• Ruflo on GitHub
• LangGraph — the rigorous alternative