Ruflo (formerly Claude Flow) is an “AI agent meta-harness” designed to run multiplayer AI and make it quick and easy to coordinate a swarm of AI agents to accomplish a task. It acts as an execution layer that wraps around Claude Code or Codex. At the time of writing, the Ruflo GitHub repository has amassed over 66k stars, largely on the strength of offering a refreshing alternative to traditional agent frameworks.
So how exactly does Ruflo stand out? Most traditional AI agent frameworks work decently well when it’s one agent doing a simple task. However, when you have to deploy a swarm of agents to accomplish a complex task, coordination issues arise. State and memory are fragmented across agents, sometimes even lost. Infrastructure costs also creep up when you’re running multiple agents at once. As developers, the time we saved on manually writing new code is now going into wiring up these agent frameworks to work properly.
Ruflo was created to address these shortcomings.
TL;DR
- Ruflo, as an AI agent meta-harness, works with Claude Code and Codex to enable efficient multi-agent AI orchestration and autonomous workflows.
- Ruflo bundles plenty of useful features, such as 100+ specialized AI agents, persistent HNSW vector memory, swarm coordination, and agent federation.
- It has both an MCP server (for Claude Code/Codex) and a CLI, bundles a SONA-based self-learning architecture, and can run autonomously in the background.
- It provides lean, efficient agent orchestration, and the benchmarks back that up.
The agent framework problem: Why traditional approaches fall short
Built for one agent, retrofitted for many
Most traditional agent frameworks were primarily built for a single agent assisting a developer in a chat interface. The typical workflow was to get an input message from the developer, perform a bunch of tasks, and respond with how that went.
The idea of orchestrating a swarm of agents came about much later, and it was built into most of these frameworks as an afterthought. Often, the orchestration doesn’t work seamlessly. State management breaks and frequently needs to be done manually, and the same goes for passing messages between agents.
Handling agent failures is another issue. To add to all of this, managing the infrastructure around these agents and keeping them up to date becomes another time sink. Manually getting into the finer details of managing memory, setting up failovers, etc., requires significant DevOps skills, which kind of beats the AI promise of ‘vibe engineering’.
The bottom line is that you need an agent framework that was designed from the ground up to handle multi-agent orchestration with all the memory management and effective coordination patterns baked in. Something that just works out of the box.
The current agent framework landscape
When it comes to orchestrating multiple agents, Claude Code and Codex have introduced some sort of subagent capabilities, but they fall short on key issues such as centralized memory management. Then there are frameworks such as LangGraph (by LangChain) and AutoGen (by Microsoft), which are designed for handling complex work, but you still have to manually define what each agent does and how they will coordinate.
While this works out well from a predictability and control standpoint, it needs significantly more effort to set up and maintain. CrewAI comes close to an ideal setup with role-based coordination but needs some configuration to get started.
Finally, if building the harness itself becomes another project, it eats into the time you can spend on actually building your main project.
Enter Ruflo: The AI-native agent meta-harness
Ruflo offers a unique meta-harness approach that solves most of the problems we discussed earlier. With a persistent self-learning system, the tool only gets better with each use. It seamlessly operates swarms of agents in parallel, and handles memory using a built-in HNSW store that persists across sessions.
It comes with 100+ predefined agents specializing in various tasks such as coding, testing, security, etc., and federates work between them with minimal human effort. In short, it’s like hiring and running an end-to-end engineering team, with their manager, on your command line. (There is also a Web UI in Beta.)
What is Ruflo? Architecture & philosophy
Overview
Ruflo is an open-source AI agent meta-harness purpose-built for deploying and coordinating multi-agent swarms. It aims to reduce operational overhead by baking in the tools, agents, and patterns required for real, parallelized agentic workflows. It was formerly known as Claude Flow, and it has been trending on GitHub with about 66k stars, 1.6k releases, and 7.9k forks at the time of writing.
Core architecture: Agent = Model + Harness
Ruflo presents itself as a “meta-harness”. Let’s break this down. An AI agent is typically an LLM (the model that reads and writes tokens), bundled with a harness (the execution layer that controls the system prompt and conversation loop, handles sandboxing, and provides tools, memory, etc.). Now, Claude Code and Codex already operate as harnesses. Ruflo is a meta-harness that operates around Claude Code and Codex, while also bundling tools, an integrated self-learning memory, agent specifications, and federation systems. It is a single framework that can run multiple AI agents at once and have them collaborate with each other.
Ruflo can be installed as an MCP (Model Context Protocol) server for Claude Code/Codex, allowing ready integration with your existing workflows around these tools. It comes readily bundled with 100+ agents specialized for many common engineering tasks such as coding, security, docs, and more.
Why it's different: Not just another agent wrapper
Ruflo is not just another wrapper or harness. It aims to be a comprehensive meta-harness providing everything a multi-agent system needs as built-ins. This includes tried-and-tested coordination patterns, federation, and self-learning that is backed by a built-in memory store that persists across sessions.
The sheer comprehensiveness is unmatched by any other tool that we know of. It can be used as an MCP server or as a CLI tool, it can spin up background workers as necessary, and it comes with 100+ agents built in. All of these features make it production ready for most use cases straight out of the box.
Getting started with agent orchestration is almost instant — it needs just 2 commands to integrate with your existing Claude Code setup:
# Command 1, installing and initializing
# For POSIX shells (MacOS/Linux/WSL/Git-Bash)
curl -fsSL https://cdn.jsdelivr.net/gh/ruvnet/ruflo@main/scripts/install.sh | bash
# Alternate command 1, for all platforms
npx ruflo@latest init wizard
# Command 2, for adding Ruflo MCP to Claude Code
claude mcp add ruflo -- npx ruflo@latest mcp start
That’s it! Your agents can now start working together in parallel with a shared and persistent memory.
Key features: Powering multi-agent AI and scalable automation
Unmatched agent orchestration and coordination
To start with, Ruflo has 100+ prebuilt agents for handling the whole development process, whether it’s coding or security audits. They are organized into 16 roles across 8 categories as per the documentation.
Next, Ruflo also handles how these agents work together, providing 6 swarm topologies (hierarchical, mesh, etc.) and 5 consensus strategies for parallel-working agents (Byzantine, Raft, Gossip, etc.). However, if all of this is confusing to wrap your head around, you simply don’t need to. Ruflo has intelligent routing to pick the best agent/model for a task, claiming 89% accuracy at doing so.
Self-learning & intelligence capabilities
Ruflo is a self-learning harness, which means it learns from every run, with everything that goes right or wrong. And it persists this knowledge across sessions. It bundles SONA (Self-Optimizing Neural Architectures), which enables models to continuously learn instead of being retrained.
It also includes ReasoningBank, which enables it to persistently store, reuse, and improve reasoning paths that work. With recallable reasoning, token usage can be reduced for reasoning-heavy tasks. Finally, it can also run 12 background workers to automatically handle tasks such as auditing, optimization, and learning. So Ruflo can work away even when you aren’t prompting it.
Memory & knowledge management
Ruflo bundles its own vector database (AgentDB) to store context across sessions. For example, you could say “Jost is my favorite font” and Ruflo would store that and recall it even a few weeks later. The database enables cross-session persistence, meaning agents can recall stuff from previous sessions as well. It also doubles up as a shared memory space when multiple agents are running in parallel, facilitating effective coordination.
The vector database is backed by built-in HNSW (Hierarchical Navigable Small World) indexes for finding ANNs (Approximate Nearest Neighbors). The HNSW index enables 1.9x faster retrieval with N=20k (20k vectors in the index) and ~3.2x-4.7x faster retrieval at N=5k, compared to brute force (naively comparing input vectors against every vector in the database). Ruflo also comes with a RAG (Retrieval Augmented Generation) memory plugin that handles hybrid search, graph hops, and diversity ranking.
Production-ready infrastructure
Ruflo contains everything you need to run AI agents in production capacity. It supports 5 LLM providers, namely Claude, GPT, Gemini, Cohere, and Ollama, and also handles failover. If one provider fails, it can automatically use others. It also ships an MCP server so it can natively integrate into your existing workflow with Claude Code or Codex. It can also federate agents with zero-trust, enabling agents to collaborate remotely.
Finally, it also handles security with a dedicated security audit that can scan for vulnerabilities and CVEs, and another AI defense layer that can block prompt injections and detect PII (Personally Identifiable Information). With all of this baked in, you don’t need to spend your precious time setting up, scaling, and managing infrastructure just to run some AI agents.
For a quick demonstration, we show how Ruflo runs with Claude Code for an example task: reviewing a simple codebase for security and quality issues. We start with the prompt “Spawn a Ruflo Swarm to review the code in this folder for security and quality issues”. Some key sections of the run are shown below:
All of this happened out of the box after setting up Ruflo, in the usual Claude Code workflow. No other special wiring was needed.
Performance benchmarks: The numbers don't lie
Head-to-head: Ruflo vs. LangGraph/AutoGen/CrewAI
Ruflo has published benchmarks comparing various performance metrics against other agent frameworks. These benchmarks were run on Apple Silicon M series, and a Linux x86_64 system running Ubuntu 24.04.
Ruflo was the clear winner for cold start time, single turn dispatch, and peak memory. For cold starts, Ruflo started in under 3.93 ms at worst (on an M-series chip), and the next best was AutoGen (at least 39x behind, on an x86_64 chip). CrewAI was the worst performer, more than a 1000x slower than Ruflo. For single turn dispatch, Ruflo took 0.053 ms at worst (x86_64) with CrewAI coming in a close second and LangGraph performing the worst by at least 500x (x86_64).
Ruflo also used the least peak memory, less than 62 MB, with AutoGen coming in second at around 78 MB. CrewAI scored the worst here with memory exceeding 250 MB. With the other two metrics (composing 50 tools and parallel wall with n=10), Ruflo was second only to CrewAI, 1.5x and 8x behind respectively.
What this means in practice for agent orchestration & AI
It is important to note that these benchmarks measure the framework overhead and have nothing to do with the LLMs used or how well they use the tools. The low single turn dispatch (about 50 microseconds) means that the framework overhead is significantly less than the LLM response time (a few seconds).
Next, with much less RAM usage, it becomes easy to scale and run multiple agents in parallel. Running 10 Ruflo agents uses only 60 MB, which is about as much as a single browser tab. Running 100 agents in parallel should be a breeze on most PCs. Finally, the extremely low cold start times mean that you can easily deploy Ruflo in container environments.
Vector memory performance
Ruflo also benchmarked the vector (HNSW) memory that it ships with. No other frameworks have this feature baked in, so it was benchmarked against brute-force retrieval over a fixed set of vectors. With 20k vectors, Ruflo’s memory is 1.9x faster than brute force. With 5k vectors, it is 3.2x - 4.7x faster. There is a crossover point for the number of vectors N (pretty small), beyond which getting ANNs via HNSW is more efficient. So for most real use cases with thousands of points to remember over time, the memory store actually works better than brute force.
When to choose Ruflo
Ideal use cases for Ruflo
Ruflo really shines in two key areas: multi-agent coordination and self-learning capabilities. It is one of the best frameworks for building teams of specialized agents that need to share knowledge and coordinate. Next, the self-learning capabilities ensure that agents learn from running tasks and get better with time. All of this closely integrates with Claude Code and Codex, so developers who are already using these tools will find Ruflo to be a good enhancement to facilitate seamless agent orchestration.
Further, Ruflo is open source and offers a degree of flexibility and control over how it works. That makes it well suited for scenarios where you need to deploy customized agents and have full control over your agent stack.
When to consider alternatives
Ruflo might be overkill if you just need one agent doing one thing. Using Ruflo for something like a simple pair programming task would be analogous to hiring an entire engineering team (with a manager) for a job that an intern could do. If you don’t need extensive agent orchestration, shared memory, and all that, you can skip Ruflo in favor of traditional agent frameworks. If your typical tasks are simple enough and don't need your agents to continuously learn and self-improve, Ruflo’s learning capabilities only add overhead.
Finally, sometimes if it's easier to delegate some of your operations to third-party infrastructure instead of having your agents build and operate it, a simple agent framework would suffice. For example, if you’re running a scraping workflow, you can just delegate JS rendering, bypassing anti-bot measures, and even data extraction to the ScrapingBee API.
Ruflo vs. other agent frameworks
Compared to LangGraph by LangChain, Ruflo is simply more comprehensive and offers much more out of the box, shipping 100+ agents that can readily coordinate as swarms and use a shared memory. It also handles federation natively. Compared with AutoGen and CrewAI, Ruflo bundles a very capable memory system backed by HNSW-index-based vector retrieval.
With this, agents can efficiently remember context and instructions across sessions for weeks. It also builds self-learning capabilities on top of this. Overall, Ruflo stands out for being production-ready and providing several useful features with minimal configuration overhead.
Getting started with Ruflo
Installation
There are multiple methods to install Ruflo. For macOS, Linux, WSL, and Git-Bash, you can use the one-line install command:
# One-line installer, POSIX shells only
curl -fsSL https://cdn.jsdelivr.net/gh/ruvnet/ruflo@main/scripts/install.sh | bash
For a more platform-agnostic installation, you can use npx or npm which works on all platforms including Windows powershell and cmd. You can use an interactive setup wizard or just install it globally:
# Interactive setup wizard; all platforms including Windows
npx ruflo@latest init wizard
# Or do a global install
npm install -g ruflo@latest
Core CLI usage
To spawn the Ruflo MCP server, the command is:
npx ruflo@latest mcp start
To configure Claude Code to spawn this MCP server automatically and use it, you can do a one-time setup.
claude mcp add ruflo -- npx ruflo@latest mcp start
You can also use Ruflo via the CLI directly. For example, the following command spawns a single coding agent:
npx ruflo@latest agent spawn -t coder --name ai-coder
The CLI can also be used to spawn and manage swarms:
# Spawn a swarm with a task
npx ruflo@latest hive-mind spawn "Do a security and code quality audit on this folder"
# Check status of the swarm
npx ruflo@latest hive-mind status
# Check memory usage
npx ruflo@latest hive-mind memory
Ruflo vs. managed solutions: The operational burden
The DIY agent orchestration vs. managed data extraction decision
An agent orchestration framework like Ruflo only handles the bit where multiple agents need to be run and coordinated. If you’re running it yourself, you have control over how this happens. The logic for the agents talking to each other and learning from tasks sits on your infrastructure.
Now, consider using AI agents for data extraction. Ruflo will not automatically be able to handle the various challenges in this process, such as managing proxies and IP rotations, extracting structured data from web pages, handling JavaScript-rendered web pages with headless browsers, and so on.
At best, the AI agents will spend time and tokens to build all of this on your machine, or put together a set of discrete services for each of these functions.
To make this easier, a managed solution like ScrapingBee can be used on its own or paired with an agent framework like Ruflo. The ScrapingBee API handles most of the infrastructure specifically required for data scraping and extraction, such as bypassing anti-bot measures, proxies, etc. It provides clean, RAG-ready output that can be readily used by AI agents. This offsets some major infrastructural requirements on your end, especially on a system where just the AI agents take up quite a bit of the resources.
When a managed solution (like ScrapingBee) makes more sense
For workflows that involve managing infrastructure that is not necessarily just for running LLMs or orchestrating them, a managed solution would make more sense. Scraping and data extraction is one such example, where the kind of services required are rotating proxies, headless Chrome instances, and so on.
The AI model or agent may be helpful to draft the API call or just convert free text or HTML into structured data. A service like ScrapingBee comprehensively handles all parts of this, not using dedicated agents or AI skills, but just basic tunable API parameters. For even AI-based data extraction, you can ask ScrapingBee to use its own LLM on the backend instead of you setting up AI agents. You get the following just by calling a single API:
- Managed proxies, just set
premium_proxy=true - JavaScript rendering, set
render_js=true, on by default - Structured Data Extraction: choose from simple CSS selectors, AI data extraction, or Markdown output. For AI data extraction, ScrapingBee handles the LLM on its backend.
And all of these can scale as you go. While using the API, you can scrape 10 pages today and 1,000 pages tomorrow without worrying about how to scale up your infrastructure.
Moreover, it's not like you have to use a managed service instead of an agent framework — they can actually work well together. For example, an AI agent that uses ScrapingBee will get a data extraction task done more easily than if it tries to set up headless browsers and proxies on its own.
Conclusion: Choosing your path to agent orchestration
For teams that need more than just agent coordination
Ruflo ships everything you need for running coordinated AI agents straight out of the box. This includes 100+ agents covering everything from writing the code to auditing and securing it. It handles federation, includes self-learning capabilities, and ships an inbuilt memory store to help agents remember context across sessions and share it with each other.
However, not all problems can be solved by agent coordination alone. Sometimes you (or your agents) might find it much easier to delegate pieces of your workflow to a managed service.
Specifically, in the case of data extraction, the ScrapingBee API handles the whole scraping workflow in a single API call using a comprehensive infrastructure stack on its backend. Running such a complex infrastructure stack on your own for simple workflows may not be worth it, even with a coordinated swarm of AI agents at your disposal.
Next steps & resources
To recap, here are some useful links for Ruflo:
If you want to check managed data extraction using ScrapingBee
Final thought
Frameworks such as Ruflo excel at handling multiple AI agents that are specialized in different tasks, effectively coordinating to work on a goal. They also ship memory and continuous learning for AI agents. However, they don’t automatically solve all problems.
For example, tasks such as scraping and data extraction need dedicated infrastructure. That’s where a solution like ScrapingBee comes in — it can be used on its own or used by AI agents to handle most data extraction workflows without having to set up any dedicated infrastructure. You can take ScrapingBee for a spin with a 1,000-credit free trial.
