Two-Pack, Four-Pack, and Six-Pack Workflows in SwarmForge: A Complete Comparison

SwarmForge provides three distinct pack workflows—two-pack, four-pack, and six-pack—that define agent topology and hand-off pipelines, ranging from rapid backend tasks to high-stakes projects requiring full specification and dedicated QA roles.

SwarmForge, an open-source multi-agent orchestration framework maintained by Uncle Bob (Robert C. Martin), uses these predefined pack configurations to balance development speed against specification granularity. Each pack adds specialized roles that handle specific quality gates, allowing teams to match their workflow complexity to project risk and scope.

What Are SwarmForge Pack Workflows?

Pack workflows in SwarmForge determine how specialized AI agents collaborate through structured hand-offs. According to the repository's README.md (lines 21-52), each pack defines a specific sequence of roles—such as coder, cleaner, and specifier—that transform user requirements into production-ready code through discrete, verifiable stages.

The three available packs differ primarily in role specialization and quality-gate separation. The two-pack workflow bundles responsibilities for speed, while the six-pack workflow isolates every major concern—from Gherkin specification to mutation testing—into dedicated agents.

Role Architecture and Granularity

Two-Pack Workflow

The two-pack workflow targets quick backend tasks where velocity outweighs extensive specification. It uses only two distinct roles: the coder produces implementation code, then hands off to the cleaner for refactoring and hardening, which returns the work to the coder for final adjustments.

As documented in README.md (lines 21-28), this workflow has no Gherkin specification layer; the coder works directly from user requirements. Quality gates—including DRY principle enforcement, CRAP score review, and basic mutation hardening—are bundled within the single cleaner role.

Four-Pack Workflow

The four-pack workflow introduces specification discipline for moderate-sized projects. The role pipeline follows: specifier → coder → refactorer → architect → specifier.

According to README.md (lines 30-39), the specifier generates Gherkin acceptance criteria before implementation begins. The refactorer handles cleanup and adds property-based tests, while the architect reviews module boundaries and structural integrity before returning work to the specifier for final approval.

Six-Pack Workflow

The six-pack workflow provides maximum rigor for large, high-stakes projects requiring comprehensive verification. The full pipeline spans six hand-offs: specifier → coder → cleaner → architect → hardender → QA → completion.

As specified in README.md (lines 41-52), the specifier defines both Gherkin specs and QA procedures upfront. The hardender agent performs dedicated mutation testing, while the QA role executes end-to-end verification scripts before signaling completion. This separation ensures no single agent handles multiple critical quality gates.

Configuration and Implementation

Each pack resides on its own Git branch (two-pack, four-pack, six-pack) with a branch-specific swarmforge.conf file that declares active windows and backends.

Two-Pack Configuration

# swarmforge/swarmforge.conf (two-pack branch)

window coder   codex   coder
window cleaner codex   cleaner task

The task mode on the cleaner indicates it receives hand-offs from the coder and returns completed work.

Four-Pack Configuration

# swarmforge/swarmforge.conf (four-pack branch)

window specifier   codex   specifier
window coder       codex   coder
window refactorer  codex   refactorer
window architect   codex   architect task

Here, the architect serves as the final gate before returning work to the specifier.

Six-Pack Configuration

# swarmforge/swarmforge.conf (six-pack branch)

window specifier   codex   specifier
window coder       codex   coder
window cleaner     codex   cleaner
window architect   codex   architect
window hardender   codex   hardender
window QA          codex   QA task

The QA role runs in task mode, executing verification procedures defined by the specifier before final completion.

Hand-Off Pipeline Mechanics

The swarmforge/handoff-protocol.md file (lines 166-171) formally defines the exact hand-off sequences for each pack. Agents use the swarm_handoff.sh script to validate and queue transitions.

For example, a four-pack hand-off from coder to refactorer generates YAML like:

type: git_handoff
to: refactorer
priority: 10
task: implement-login
commit: a1b2c3d4e5

The protocol ensures each commit resolves to a canonical 10-character SHA before queuing, preventing merge conflicts during parallel agent operations.

Specification and Quality-Gate Ownership

The primary architectural difference between packs lies in how they distribute specification and verification responsibilities:

• Two-Pack: No upfront specification; quality gates bundled in cleaner
• Four-Pack: Gherkin specs required; separates refactoring from architectural review
• Six-Pack: Full QA procedures defined upfront; mutation testing isolated in hardender role

This progression allows teams to trade setup overhead against defect prevention, with the six-pack workflow catching structural issues through dedicated architect review and logical errors through hardender mutation testing.

Summary

• Two-Pack: Minimal role separation (coder → cleaner → coder) for rapid backend tasks without Gherkin specifications.
• Four-Pack: Moderate granularity with four roles including dedicated specifier and refactorer for projects needing compact specifications.
• Six-Pack: Maximum separation of concerns across six roles, including hardender for mutation testing and QA for end-to-end verification.
• Each pack lives on a dedicated Git branch with a customized swarmforge.conf declaring the active agent topology.
• The swarm_handoff.sh script and handoff-protocol.md enforce consistent commit-based hand-offs across all workflows.

Frequently Asked Questions

What is the minimum number of agents required to run SwarmForge?

You can run SwarmForge with just two agents using the two-pack workflow, which requires only a coder and a cleaner as defined in swarmforge.conf. This configuration works for small backend tasks where the cleaner handles all quality gates including refactoring and basic hardening.

Does the four-pack workflow support mutation testing?

No, the four-pack workflow does not include a dedicated mutation testing phase; it bundles hardening concerns within the architect role. For dedicated mutation testing, you must use the six-pack workflow, which includes the specialized hardender agent that runs mutation tests before the QA verification stage.

How do I switch between pack workflows in SwarmForge?

Switching requires checking out the corresponding Git branch (two-pack, four-pack, or six-pack) and verifying that your swarmforge.conf matches the branch-specific role topology. The swarmforge.sh launcher script then creates the appropriate tmux worktrees and initializes the correct agent prompts from the swarmforge/roles/ directory.

Where are the agent prompts defined for each role?

Each role's system prompt resides in swarmforge/roles/<role>.prompt (e.g., specifier.prompt, architect.prompt). These files contain the specific instructions that define agent behavior, quality criteria, and hand-off protocols for that role within the chosen pack workflow.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}