myAI vs Ruflo

TL;DR: Ruflo (formerly claude-flow, renamed early 2026) orchestrates many agents inside one session — swarms, hive-mind coordination, parallel lanes attacking a single large task. myAI persists identity and work across sessions, machines, and models. They operate on different axes: Ruflo makes one session wider, myAI makes every session continuous. They compose — a myAI runner session can drive Ruflo inside it.

What Ruflo does well

Serious in-session parallelism. Swarm topologies, queen/worker hive-mind coordination, and a large MCP toolset let dozens of agents decompose and attack one big task concurrently. For "refactor this entire codebase tonight" workloads, fan-out at this scale is the point.
Deep Claude Code integration. Hooks, slash-command ergonomics, and coordination primitives built specifically for the Claude Code runtime, by a very active community that iterates fast.
In-run memory. SQLite-backed shared memory lets swarm agents coordinate — agent A's discovery is visible to agent B within the run.
Free and local. Runs on your machine, on your Claude subscription, no service dependency.

When you should choose Ruflo

You have one large task right now and want maximum parallel throughput inside the session you're sitting in.
You want to experiment with multi-agent topologies (mesh, hierarchical, consensus) on real work.
Your pain is "one agent is too slow for this task," not "every agent forgets everything between tasks."

What myAI adds that Ruflo doesn't attempt

Ruflo's coordination — memory included — is scoped to the run. When the session ends, the swarm's working context is gone the way all session context is gone: the next session starts blank. myAI is built for exactly that boundary:

Cross-session, cross-machine, cross-agent continuity. State, handoff notes, and a distilled memory corpus persist in a gateway any MCP-capable agent connects to — Claude Code today, Cursor or Codex CLI tomorrow, your laptop tonight, your desktop in the morning. The boot bundle means a blank agent already knows your operator context, what shipped, and what's next. Ruflo doesn't try to be this; it's a session-scoped tool by design.
A persistent task queue + off-hours runner. Work you queue today gets built overnight by a headless runner on your machine, on subscription billing, and lands in a review lane. Ruflo executes when you invoke it; myAI keeps executing when you're asleep.
Budget guarding. Swarms are token-hungry — genuinely the fastest way to burn a rolling window. myAI meters your subscription's real output-token burn across all sessions and checkpoints work before the window strands it. If you run big swarms, you need this more, not less.
Fleet scope. Ruflo runs in a repo. myAI manages the 25-repo fleet around it: shared gateway, app directory, morning review console, health checks.
A review gate. Autonomous work lands on a test branch in review status — nothing merges without you. Orchestration frameworks optimize for output volume; myAI's loop is built around the operator staying in control of what ships.

Where Ruflo is genuinely ahead

Within-session throughput. myAI does not parallelize agents inside a session — its runner works one task per tick, deliberately. If raw fan-out is your bottleneck, Ruflo (or Anthropic's official Agent Teams) is the right tool.
Coordination research surface. Topology selection, consensus mechanisms, neural pattern training — Ruflo explores coordination ideas myAI has no ambition to own.

Using both

This is the most naturally composable pairing on the comparison list. myAI sits above the session; Ruflo sits inside it:

Queue a large task in myAI (myai schedule).
The overnight runner claims it and opens a headless Claude Code session — which can invoke Ruflo to swarm the task.
The session closes: myAI captures state, handoff, and a session summary; the work sits in review.
Next morning, any agent on any machine boots with full context of what the swarm did.

Ruflo makes the session powerful; myAI makes sure nothing the session learned dies with it.

Side by side

	myAI	Ruflo
Axis	Continuity across sessions/machines/agents	Parallelism within one session
Memory	Persistent: RAG corpus + git-versioned brain, survives everything	SQLite swarm memory, scoped to coordination
Agent support	Any MCP-capable agent (Claude Code, Cursor, Windsurf, Codex CLI)	Claude Code
Task queue + overnight runner	✅	❌ (executes when invoked)
Budget guard	✅ subscription rolling window	❌
Fleet management	✅	❌
In-session multi-agent fan-out	❌	✅ core strength
Review gate before merge	✅	❌

Bottom line: if your problem is this task is too big for one agent, use Ruflo. If your problem is every session starts from zero — across repos, devices, and models — that's myAI. Since the problems are orthogonal, the strongest setup for a Claude Code power user is arguably both.

Back to the comparison overview · Concepts