Ruflo Turns Claude Into an Agent Swarm. Here's

I have a complicated relationship with "automate ANYTHING" content. My feed is full of it. Nine-minute demos where someone types a prompt, six agents spin up, and suddenly a whole content operation writes itself into an Obsidian vault while the creator gestures triumphantly at their screen. Half the time it's impressive. Half the time it's a very convincing demo of a very specific workflow working perfectly once, on camera.

So when Julian Goldie dropped a video on Ruflo — a free Claude Code extension for deploying multi-agent swarms — I wanted to look at it carefully. Not dismissively, not credulously. Just: what's actually here?

I'll be upfront: I watched the demo and pulled Ruflo's GitHub page. I didn't run a full install myself for this piece — partly timeline, partly the fact that Claude Code access varies enough across setups that my friction points might look completely different from yours. What I can do is tell you what Goldie's demo shows, what it glosses over, and what I think the more interesting questions actually are.

What Ruflo Actually Does

The core idea is clean: Ruflo is an orchestration layer that sits on top of Claude Code and lets you spin up multiple specialized agents that work in parallel, rather than having Claude handle everything sequentially in one context window.

Goldie's kitchen analogy is genuinely useful here: "There's a head chef which is the router, and then there are specialist cooks — the agents — one for salads, one for grills, one for desserts." The router agent receives your task, breaks it into subtasks, and hands those off to specialist agents who work simultaneously. You get parallel execution instead of Claude doing one thing, finishing, then doing the next thing.

In the demo, he runs a content production workflow — SEO keyword research and article briefing for the "AI agents automation" niche — and watches six agents build out a research team, do the work, and write the outputs directly into his Obsidian vault as markdown files. It's genuinely satisfying to watch. The progress tracker shows tasks completing. Files appear in real time. "The SEO architect has consolidated the research into Obsidian now," Goldie narrates, with the audible energy of someone watching a thing actually work.

The install is CLI-based (GitHub instructions, paste into terminal, verify it's running inside Claude Code), and the tool is free. Those two facts together are worth noting — the barrier to entry is low enough that this isn't just for people with cloud infrastructure budgets.

The Obsidian Thing Is More Interesting Than It Looks

Here's where I want to slow down, because there's a real architectural insight buried in what looks like a productivity tip.

During the demo, Goldie asks Claude to suggest Ruflo use cases based on his context — and Claude responds that it has no saved memory of him. This despite the fact that he uses Claude daily. His fix: point Claude at his Obsidian vault.

"This is why it's really useful to have an Obsidian or second brain," he says. "You want to really understand how to store your memories in context of you, just in case stuff like that happens."

This moment accidentally exposes something important. Claude's memory behavior is not consistent across contexts — it varies significantly depending on whether you're using Claude.ai, the API, or Claude Code, and what tier you're on. Assuming you'll have continuity and then discovering mid-workflow that you don't is the kind of thing that breaks automations in annoying ways. Goldie's workaround — using Obsidian as an external persistent memory layer that agents can read from and write to — is actually a robust solution to a real problem. Externalizing memory into a tool you control means you're not at the mercy of whatever Anthropic decides to do with session context this week.

The practical implication: if you're building serious agent workflows, you probably want some form of external memory store regardless of what the underlying model promises. Obsidian is one option. There are others. The point is to own the context layer yourself.

What the Demo Doesn't Show

Goldie mentions in passing, almost as a footnote, that running large agent swarms "will use more tokens." That deserves more than a footnote.

When you spin up six agents working in parallel, each one is running its own context. Depending on task complexity, you could burn through tokens at 6x the rate of a single Claude session. At scale — and Goldie references being able to run up to 100 agents based on the demo narration, though I haven't verified that number against Ruflo's actual documentation or GitHub specs, so treat it as a demo framing rather than a confirmed hard limit — the cost picture changes significantly. Free tool, yes. But the API calls powering those agents aren't free, and that math compounds fast.

There's also a prompt-specificity requirement that came up and I think is underplayed. As Goldie notes: "When you're using Ruflo swarms with Claude, you want to make sure that you specifically tell it in the prompt to use Ruflo. Otherwise, what will happen is it will just use Claude directly for agent swarms, which is not what you want." That's a workflow discipline requirement — every prompt needs to be deliberate about invoking the framework. In a high-volume content operation, that's manageable. For someone experimenting casually, it's an easy thing to forget and wonder why nothing looks different.

The Hermes Question, Briefly

During the live Q&A, several viewers asked about "Hermes" in the context of agent configuration and security. Goldie gave some advice about not giving it access to things you're not comfortable with, and mentioned Docker sandboxing as a safer option.

Worth clarifying for anyone who wasn't tracking: Hermes (likely referring to a local LLM agent runner, separate from Ruflo itself) appears to be a different tool that some of Goldie's audience is using alongside or instead of Claude Code for agent workflows. The security advice — don't grant file system or API access beyond what the agent actually needs, consider sandboxing — is sound general practice for any autonomous agent system that can read and write files on your machine. It's not Ruflo-specific, but it's the right instinct. Agents that can take real-world actions need real permission boundaries.

The Bigger Thing I Keep Thinking About

Here's what I actually want to talk about.

A viewer in the chat asked whether Ruflo is even relevant given that Claude already has native parallel agent capabilities. Goldie's answer: "Claude already had a setup where you could run agent teams in parallel, but with Ruflo you can create like 100 agents in parallel. So it's quite different."

That's a real distinction for power users. But the more interesting competitive question is the other direction: how long before Anthropic or OpenAI just absorbs this capability natively? Third-party orchestration layers have a complicated history. Some become infrastructure (LangChain survived, sort of). Others get rendered obsolete by a model update. Ruflo's value proposition depends partly on there remaining a gap between what Claude Code does natively and what Ruflo enables. Anthropic is not standing still on agentic workflows.

I don't raise this to be dismissive — Ruflo is free, it works in the demo, and the gap it fills is real right now. But anyone building production workflows on top of it should have an eye on that dependency.

The deeper thing, though, is this: tools like Ruflo don't just make individual work faster. They change what "a team doing this" means. Goldie frames this explicitly — Ruflo "automates tasks that you probably have a team of people doing." The restaurant kitchen isn't a metaphor for how Claude works; it's a metaphor for an organizational structure that previously required multiple humans with specialized skills.

I'm 26. A lot of my peers are doing exactly the kinds of work these swarms are designed to replace — content operations, research pipelines, SEO briefing. The pitch is productivity. The actual mechanism is compression: fewer humans needed per unit of output. That's not an argument against using the tool. But I'm skeptical of framing that treats organizational compression as purely a personal productivity win, when the aggregate effect is something else entirely. The question isn't whether you can run 100 agents. It's what the labor market looks like when everyone can — and what kinds of work remain distinctively human when the bottleneck isn't horsepower, it's judgment.

That's the thing the demo doesn't show you: not because Goldie is hiding it, but because no nine-minute video can hold it. We're not watching a better assistant. We're watching a prototype of a different organizational model, running in someone's terminal, writing markdown files into an Obsidian vault. And it mostly works.

By Yuki Okonkwo, AI & Machine Learning Correspondent