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:

1. Queue a large task in myAI (myai schedule).
2. The overnight runner claims it and opens a headless Claude Code session — which can invoke Ruflo to swarm the task.
3. The session closes: myAI captures state, handoff, and a session summary; the work sits in review.
4. 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

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