@yibie: The author of “Clean Code” breaks software engineering discipline into an agent pipeline—each quality gate is an independent role, and chained together they form a complete development workflow. SwarmForge (Uncle Bob’s new project): the entire coordination mechanism is the file system, with agents communicating via git commits…
Robert C. Martin (author of “Clean Code”) has released SwarmForge: a minimalist multi-agent orchestration framework built on tmux, git worktree, and prompt files. It reduces all coordination to file-system operations and supports three quality-gate pipelines: two-pack/four-pack/six-pack.
The author of “Clean Code” breaks software engineering discipline into an agent pipeline—each quality gate is an independent role, and when chained together, it forms a complete development flow.
SwarmForge (Uncle Bob’s new project): the entire coordination mechanism is the file system. Agents talk to each other through git commits and handoff files, and each role gets its own isolated workspace.
SwarmForge: Uncle Bob’s tmux multi-agent orchestration — everything is a file
What it is
Robert C. Martin’s (author of “Clean Code”) project: an orchestration layer for multi-agent collaboration built on tmux. It’s in the same lane as herdr and Agent Relay, but with a completely different approach:
• herdr: Rust binary, agents in a single process, controlled via socket API
• Agent Relay: channels + DM messages
• SwarmForge: bash + tmux + git worktree + prompt files. Everything is a file
The tech stack is extremely minimal: zsh + git + tmux + Babashka. No Rust, no Postgres, no socket API. All configuration consists of prompt text files.
Core mechanics
1. Role = git worktree
Each agent role gets its own git worktree so they never step on each other—git worktree’s native isolation means you don’t need to invent file locks:
• coordinator → master (main workspace)
• coder → .worktrees/coder/
• architect → .worktrees/architect/
2. Configuration = one conf file
One window per line: role name, agent CLI, worktree, receive mode. Each role gets a prompt file:
window coordinator codex master
window coder codex coder
window architect claude architect task --dangerously-skip-permissions
3. Communication = file handshake
Agents don’t talk directly. Three scripts: swarm_handoff.sh (submit handoff), ready_for_next.sh (accept next task), done_with_current.sh (finish current task). A background daemon does the delivery—copying A’s outbox into B’s inbox. Agents never touch the tmux socket; the daemon is the only owner of tmux.
4. Three pipelines (branches)
• two-pack (2 roles): coder → cleaner → coder—fast iteration on small tasks
• four-pack (4 roles): specifier → coder → refactorer → architect—medium projects
• six-pack (6 roles): specifier → coder → cleaner → architect → hardender → QA—full quality gates
5. Constitution
A constitution.prompt points to multiple articles in constitution/articles/ (engineering standards, handoff protocols, workflow rules), which are injected into every agent’s context. Shared articles live on the main branch; local overrides use local-*.prompt.
Uncle Bob’s unique philosophy
The most interesting part is the discipline design of the roles—they map to classic software engineering practices:
• specifier writes Gherkin acceptance specs and confirms them with you first
• coder implements with TDD
• cleaner does CRAP/DRY review (complexity metrics)
• hardender runs mutation testing (deliberately altering code to see if tests catch it)
• QA turns acceptance workflows into executable scripts
This is the “Clean Code” textbook broken down into agent roles. Uncle Bob uses an agent swarm to implement his ideal software development discipline—each quality gate is an independent agent, chained into a pipeline.
How to get started
BRANCH=four-pack # two-pack / four-pack / six-pack
curl -L "https://github.com/unclebob/swarm-forge/archive/refs/heads/…${BRANCH}.tar.gz" | tar -xz --strip-components=1
./swarm
Dependencies: zsh, git, tmux, Babashka, plus an agent backend (codex/claude/copilot/grok). The windows open automatically; the first window is the cleanup window (closing it = shutting down the whole swarm).
In one sentence
SwarmForge is the ultimate expression of the “files as state” philosophy—no database, no API, no message queue. Agents communicate via git commit + handoff files; each role has one worktree, one tmux window, one prompt file. It’s the exact opposite direction from herdr (API-driven): reducing coordination to the simplest form bash can express. It’s great for local multi-agent collaboration experiments and also works as a teaching tool—every layer is visible and tangible.
Original: https://github.com/unclebob/swarm-forge…
#multi-agent-orchestration #tmux #UncleBob
SwarmForge is a tmux-based agent orchestration platform that coordinates multiple AI agents working on separate git worktrees, offering role-based workflows like two-pack, four-pack, and six-pack for disciplined software engineering.
A practical guide for developers (especially AI coding tool users) on how to safely and efficiently use Claude Code, Codex, and other tools for multi-agent parallel development, focusing on best practices such as task decomposition, file isolation (worktree), boundary control, sequential merging, etc., to avoid file conflicts and chaos.
This tweet introduces the 9-step guide for Claude Code Dynamic Workflows, emphasizing structured loops and best practices for multi-agent workflows, including manual review, worktree isolation, and automatic rework, pointing out that this is the key to turning agent swarms from toys into productivity.
Recommends a comprehensive introduction to 'Agentic Engineering Workflow', covering tmux, agent memory, skills, voice input, long task execution, parallel worktree management, multi-agent scheduling, along with the visual HTML editor Lavish and a code change validation pipeline: no-mistakes.
gstack is an open-source software factory that provides a structured workflow for Claude Code, turning it into a virtual engineering team with slash commands for each development phase. It helps solo developers ship like a team by enforcing engineering discipline.