Multi-Agent Orchestration: BMAD, Claude Flow, and Gas Town

While Claude Code and similar tools are chaning the way how we write software, they still hit fundamental limitations: one context window, one task at a time, and context loss between sessions. What if we could have multiple specialized AI agents working together, each with their own expertise, coordinating like a real development team?

That's exactly what multi-agent orchestration frameworks do. After spending time some with BMAD, Claude Flow, and Gas Town, I want to share what each does best, and how you can chain them together for maximum fun and effect.

---

The Problem with Single-Agent Development

Think about your last significant coding session with an AI assistant. You probably experienced:

• Context loss mid-conversation - The AI "forgets" earlier decisions
• Inconsistent architectural choices - Different approaches emerge in different sessions
• Hard to pick up where you left off - "Where was I?" syndrome
• Sequential bottleneck - One task at a time, no parallelization

Anthropic's own research found that multi-agent systems with Claude Opus 4 as lead and Claude Sonnet 4 subagents outperformed single-agent Claude Opus 4 by 90.2% on their internal research evaluations. The evidence is clear: multiple specialized agents beat one generalist.

Steve Yegge (creator of Gas Town) describes the different uses of agents as a journey (see below). Based on my experience, most developers are working with a generalist somewhere below stage 5.

The AI Coding Adoption Ladder

Steve Yegge describes the journey developers take with AI coding tools:

Stage	Description
1. Near-Zero AI	Maybe code completions, sometimes ask Chat questions
2. Agent in IDE, permissions on	A narrow coding agent in a sidebar asks your permission to run tools
3. Agent in IDE, YOLO mode	Trust goes up. You turn off permissions, agent gets wider
4. Wide agent in IDE	Your agent gradually grows to fill the screen. Code is just for diffs
5. CLI, single agent, YOLO	Diffs scroll by. You may or may not look at them
6. CLI, multi-agent, YOLO	You regularly use 3 to 5 parallel instances. You are very fast
7. 10+ agents, hand-managed	You are starting to push the limits of hand-management
8. Building your own orchestrator	You are on the frontier, automating your workflow

Most developers reading this are probably at stages 3-5. The frameworks in this post: BMAD, Claude Flow, and Gas Town—are tools for stages 6-8. They exist because hand-managing 10+ agents doesn't scale, and because the productivity gains from multi-agent workflows are too significant to ignore.

1. BMAD: Structure Beats Chaos

BMAD (Breakthrough Method for Agile AI-Driven Development) takes the philosophy that chaos should be fought with documentation. In BMAD, source code is no longer the sole source of truth, documentation (PRDs, architecture designs, user stories) is.

How It Works

BMAD uses 26 specialized persona agents, each embodying a specific role: Analyst, Product Manager, Architect, Scrum Master, Product Owner, Developer, and QA. Work flows through structured phases:

Phase	Agent	What it produces
1. Initialize	Analyst	Project brief, planning track selection
2. PRD	PM	Requirements, personas, success metrics
3. UX Design	UX Designer	Wireframes, interaction patterns
4. Architecture	Architect	Tech stack, data model, system design
5. Epics & Stories	PM	Sharded work units with acceptance criteria
6. Readiness Check	Architect	Validation that artifacts are complete

Each phase runs in a fresh chat to avoid context limitations. The key insight: handoffs between personas create versioned artifacts that persist in git.

The Build Cycle

For implementation, BMAD recommends:

# 1. Create story file from epic
/bmad:bmm:workflows:create-story

# 2. Implement the story (new chat)
/bmad:bmm:workflows:dev-story

# 3. Generate tests (new chat, optional)
/bmad:bmm:workflows:automate

# 4. Code review (new chat)
/bmad:bmm:workflows:code-review

Best For

• Greenfield projects that need proper planning
• Teams requiring audit trails - everything is versioned docs
• Complex requirements that need explicit documentation before coding
• Handoffs between developers - anyone can pick up a story file

The trade-off? Planning takes lots time and tokens. A typical planning phase runs about 3 hours before any code is written. But that upfront investment pays off with predictable execution.

2. Claude Flow: Memory Enables Learning

Claude Flow by ruvnet takes a different approach: rather than fighting context limits with documentation, it builds AI-native memory systems. The result is parallel agent swarms that coordinate through shared knowledge.

Architecture

Claude Flow deploys 54+ specialized agents in coordinated swarms using the orchestrator-worker pattern:

                    ┌─────────────────┐
                    │  Orchestrator   │
                    │  (Queen Agent)  │
                    └────────┬────────┘
                             │
           ┌─────────────────┼─────────────────┐
           │                 │                 │
           ▼                 ▼                 ▼
    ┌──────────┐      ┌──────────┐      ┌──────────┐
    │ Worker 1 │      │ Worker 2 │      │ Worker 3 │
    │ Backend  │      │ Frontend │      │ Testing  │
    └──────────┘      └──────────┘      └──────────┘

The Queen analyzes requests, breaks them into subtasks, assigns workers, and synthesizes results. Workers have domain expertise, execute tasks, and report back—all in parallel.

Memory Systems

What makes Claude Flow special is its memory layer:

System	Purpose
AgentDB	Vector search, 96x faster than alternatives
ReasoningBank	Learns from mistakes

Combined, agents get smarter over time, across sessions. Successful patterns are stored and reused, routing similar tasks to the best-performing agents.

Setup

# Install and initialize
npx claude-flow@v3alpha init

# Add claude-flow MCP server to Claude Code
claude mcp add claude-flow -- npx -y claude-flow@v3alpha

# Verify installation
claude mcp list

Then just tell Claude Code to use claude-flow:

Build a web-based retrospective board with claude-flow and parallel agents:
- Three columns: happy, unsure, sad
- Real-time updates using Socket.io
- Tech stack: Express.js, Socket.io, better-sqlite3

Claude Flow automatically breaks down the objective, spawns specialized coder agents, and coordinates through shared memory.

Best For

• Rapid prototyping - parallel execution is fast
• Complex parallel tasks - multiple agents working simultaneously
• Projects needing persistent memory - decisions carry across sessions
• Performance-critical work - V3 delivers ~250% improvement in effective subscription capacity

3. Gas Town: Git Survives Everything

Gas Town, Steve Yegge's January 2026 release, takes a radically different philosophy: instead of fighting chaos with structure (BMAD) or memory (Claude Flow), it embraces chaos with git as the persistence layer.

Philosophy

"Physics over Politeness" - Agents must prioritize execution over courtesy.

GUPP: Gastown Universal Propulsion Principle

"If there is work on your hook, YOU MUST RUN IT."

The key insight: Git is already a persistence layer. Why invent another one?

The 7 Worker Roles

Role	Description
Overseer	You (the human operator)
Mayor	Chief concierge, the main agent you talk to
Polecats	Ephemeral workers → MRs, then decommissioned
Refinery	Handles merge queue
Witness	Monitors polecats, unsticks workers
Deacon	Runs patrol workflows in loops
Crew	Long-lived per-rig agents for design

The magic is in Polecats, ephemeral worker agents that spawn, complete a task, create an MR, and disappear. Their context dies, but their work survives in git.

Setup

# Install (requires Go)
go install github.com/steveyegge/gastown/cmd/gt@latest

# Initialize town (creates workspace)
gt install ~/gt --git
cd ~/gt

# Add a project as a "rig"
gt rig add retro_board file:///path/to/retro_board

Working with the Mayor

The Mayor is your main interface:

gt mayor attach

Then give high-level instructions. The Mayor breaks down your request into tasks, creates a convoy with issues, spawns Polecats to do the work, and reports progress back.

Crash Recovery

This is where Gas Town shines. Close your terminal mid-work, then:

cd ~/gt
gt prime

Everything is still there because it's in git. Compare that to vibe coding where "Where was I?" is the eternal question.

Best For

• Long-running projects with many features
• Teams that need crash recovery - sessions are cattle, agents are persistent
• High throughput requirements - 15+ Polecats working in parallel
• Projects requiring full git history - every decision is a commit

The Cost Warning

Gas Town burns money, not gas. Steve Yegge reports a 60-minute session can cost about $100 in Claude tokens—roughly 10x the cost of a normal Claude Code session. The throughput is real, but so is the bill.

Chaining Them Together: The Ultimate Workflow

Here's where things get interesting. Each framework has strengths for different phases:

┌─────────────────────────────────────────────────────────────┐
│                      Your Project                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   BMAD                     (Planning)                       │
│   ├── /bmad → workflow-init                                 │
│   ├── /bmm-pm → prd                                         │
│   └── /bmm-architect → create-architecture                  │
│              │                                              │
│              ▼                                              │
│   Gas Town                 (Orchestration)                  │
│   ├── gt rig add <project>                                  │
│   ├── gt convoy create <epic>                               │
│   └── gt sling <issue> <rig>                                │
│              │                                              │
│              ▼                                              │
│   Claude Flow              (Execution - per story)          │
│   └── npx claude-flow swarm "implement story"               │
│                                                             │
└─────────────────────────────────────────────────────────────┘

The Flow

1. BMAD for Planning: Start with BMAD's structured personas to create your PRD, architecture, and epics. This gives you versioned documentation that any agent (or human) can reference.

2. Gas Town for Orchestration: Add your project as a rig in Gas Town. Create convoys from BMAD's epics. The Mayor coordinates work assignment, and Polecats handle branches and MRs automatically.

3. Claude Flow for Execution: For complex stories that benefit from parallel work, spawn a Claude Flow swarm within a Gas Town task. The memory systems help agents learn from the codebase as they work.

A Simpler Alternative: SpecKit + Gas Town

If BMAD feels heavyweight or just not your tool of choice, consider:

┌─────────────────────────────────────────────────────────────┐
│                      Your Project                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   SpecKit                  (Planning)                       │
│   ├── /speckit.specify → spec and requirements              │
│   ├── /speckit.clarify → refine                             │
│   └── /speckit.plan → research and plan                     │
│              │                                              │
│              ▼                                              │
│   Gas Town                 (Orchestration/Execution)        │
│   ├── gt rig add <project>                                  │
│   ├── gt convoy create <epic>                               │
│   └── gt sling <issue> <rig>                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Comparison Table

Aspect	BMAD	Claude Flow	Gas Town
Philosophy	Fight chaos with docs	AI-native memory	Embrace chaos with git
Workers	26 persona agents	54+ specialized agents	7 roles + Polecats
Persistence	Docs in repo	AgentDB + SQLite	Beads in git (JSONL)
Recovery	Re-read story file	Database restore	GUPP + gt prime
Best for	Planning phase	Complex parallel tasks	Long-running projects
Trade-off	Upfront time investment	Memory overhead	Token cost

When to Use What

Situation	BMAD	Claude Flow	Gas Town
New project	Structured kickoff	Rapid prototype	Needs git rig
Audit trail	Versioned docs	Memory snapshots	Git history
Parallel work	Sequenced handoffs	Swarm orchestration	Polecat crews
Fast iteration	Deliberate cadence	Quick sprinting	High throughput
Long-run scale	Governance focus	Many specialists	Durable rigs

Final Thoughts

Multi-agent orchestration isn't just about having more agents—it's about having the right agents for the right phases, with the right persistence model.

• Structure beats chaos (BMAD)
• Memory enables learning (Claude Flow)
• Git survives everything (Gas Town)

The frameworks are complementary, not competing. Use BMAD when you need upfront planning discipline. Use Claude Flow when you need parallel execution with memory. Use Gas Town when you need git-backed durability and crash recovery.

Or chain them together and let AI agents handle AI agent coordination. Welcome to the future of software development.

---

Resources

BMAD:

• docs.bmad-method.org
• GitHub - bmad-code-org/BMAD-METHOD

Claude Flow:

• GitHub - ruvnet/claude-flow
• claude-flow.ruv.io

Gas Town:

• Welcome to Gas Town - Steve Yegge
• GitHub - steveyegge/gastown