# Pack vs Forge in SwarmForge: What's the Difference?

> Understand the key differences between Packs and Forges in SwarmForge. Learn how Packs manage single AI projects and Forges host multiple projects with a shared dashboard.

- Repository: [Robert C. Martin/swarm-forge](https://github.com/unclebob/swarm-forge)
- Tags: deep-dive
- Published: 2026-09-02

---

**A Pack is a single-project AI workflow pipeline, while a Forge is a host-level environment that manages multiple projects with a shared dashboard and host lieutenant.**

SwarmForge, the open-source multi-agent orchestration platform from Bob Martin (unclebob/swarm-forge), uses these two concepts to separate lightweight project workflows from centralized project management. Understanding the distinction helps you choose the right deployment model for your AI agent needs.

## Core Difference: Scope and Function

The fundamental distinction lies in **scope** and **orchestration level**:

| Concept | Level | What It Contains | Runtime Behavior |
|---------|-------|----------------|------------------|
| **Pack** | Project | AI role definitions, [`swarmforge.conf`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge.conf), role prompts, pack-specific scripts | `./swarm` launches all agents immediately |
| **Forge** | Host/instance | `packs/` directory (all templates), `projects/` directory (instantiated packs), dashboard, host lieutenant | `./swarm` launches only dashboard and lieutenant; project agents start on demand |

According to the [`README.md`](https://github.com/unclebob/swarm-forge/blob/main/README.md) at lines 28-33, "**Packs** compose into the directory you are in" and "**Forges** install a host… `./swarm` starts the dashboard and a host lieutenant only**."

## What Is a Pack in SwarmForge?

A **Pack** is a **self-contained workflow pipeline** that defines a complete chain of AI agents for one project.

### Pack Characteristics

- Contains a fixed sequence of AI roles (e.g., *specifier → coder → cleaner → reviewer*)
- Ships with [`swarmforge.conf`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge.conf) configuration, role-specific prompts, and execution scripts
- Installs directly into your current working directory
- Runs autonomously without external orchestration

### Pack Installation and Execution

```bash

# Install a single-project Pack (e.g., the six-pack) into the current folder

get-swarm-forge six-pack   # pulls the pack scripts into .

./swarm                    # starts the six-pack agents immediately

```

The `pack_web.bb` script (lines 1888-1890) serves as the runtime for a Pack, providing its dashboard when a Pack is the active context.

### When to Use a Pack

Choose a Pack when you need:
- A **lightweight, single-project setup**
- Minimal overhead with no central management
- Direct agent execution without host-level orchestration

## What Is a Forge in SwarmForge?

A **Forge** is a **host environment** that centralizes pack management and enables multi-project workflows.

### Forge Characteristics

- Maintains a `packs/` directory with **all available pack templates**
- Contains a `projects/` directory where each subdirectory is an **independent project instantiated from a chosen pack**
- Includes a **dashboard** for visual project management
- Runs a **host lieutenant** that orchestrates multiple projects simultaneously

### Forge Architecture

As documented in [`project-board.md`](https://github.com/unclebob/swarm-forge/blob/main/project-board.md) (lines 3-6), a Forge organizes work through:

```

forge-root/
├── packs/          # Pack templates (six-pack, four-pack, etc.)

├── projects/       # Instantiated projects, each containing one pack

└── dashboard/      # Web UI for project creation and monitoring

```

### Forge Installation and Execution

```bash

# Install a multi-project Forge (project-manager) that includes all packs

get-swarm-forge project-manager   # creates packs/ and projects/ directories

./swarm                            # launches only the dashboard + host lieutenant

```

The `forge.bb` script (lines 167-170) sets up this host environment, initializing the dashboard and host lieutenant without starting individual project agents.

### Creating Projects Within a Forge

From the dashboard, you instantiate new projects using available pack templates. The underlying command structure matches:

```bash
./swarmforge/scripts/pack_web.bb new-project \
  --name my-app \
  --pack four-pack

```

### When to Use a Forge

Choose a Forge when you need:
- **Multiple concurrent projects** with different packs
- Centralized monitoring through a shared dashboard
- On-demand agent spawning rather than always-on execution
- Template reuse across many project instances

## Key Files Defining Pack vs Forge Behavior

| File | Purpose | Relevant Lines |
|------|---------|---------------|
| [`README.md`](https://github.com/unclebob/swarm-forge/blob/main/README.md) | High-level distinction between Packs and Forges | 28-34 |
| [`project-board.md`](https://github.com/unclebob/swarm-forge/blob/main/project-board.md) | Forge directory structure and pack instantiation | 3-6 |
| `get-swarm-forge` | Installer script that fetches either artifact | 9-12 |
| `swarmforge/scripts/forge.bb` | Host setup (dashboard + lieutenant) | 167-170 |
| `swarmforge/scripts/pack_web.bb` | Pack runtime and dashboard serving | 1888-1890 |

## Practical Decision Framework

**Use a Pack when:**
- You have one project to automate
- You want agents running immediately on `./swarm`
- You don't need cross-project visibility

**Use a Forge when:**
- You manage multiple AI-driven projects
- You want a central dashboard for oversight
- You prefer agents start on-demand via UI rather than automatically
- You need to compare or switch between different pack templates quickly

## Summary

- **Packs** are project-level, single-purpose workflow pipelines that launch all agents on `./swarm`
- **Forges** are host-level environments with centralized pack storage, a `projects/` directory, dashboard, and host lieutenant that defer agent startup to on-demand requests
- The `get-swarm-forge` installer fetches either artifact based on your argument (`six-pack` for Pack, `project-manager` for Forge)
- `pack_web.bb` handles Pack runtime; `forge.bb` initializes the host environment

## Frequently Asked Questions

### Can I convert a Pack installation into a Forge?

No direct conversion path exists in the current codebase. As implemented in unclebob/swarm-forge, Packs and Forges are installed through distinct paths in `get-swarm-forge` (lines 9-12). To switch, install a Forge separately and recreate your project by instantiating the equivalent pack template within the Forge's `projects/` directory.

### Does a Forge consume more resources than a Pack?

A Forge has higher baseline resource usage because the host lieutenant and dashboard run continuously, whereas a Pack only runs its specific agent chain. However, individual project agents in a Forge start on demand, potentially reducing aggregate resource consumption when many projects are idle.

### How do I know whether `./swarm` will start agents or just the dashboard?

Check your directory structure. If you're in a Pack directory, `./swarm` launches agents directly. If you're in a Forge root with `packs/` and `projects/` subdirectories, `./swarm` starts only the dashboard and host lieutenant. The [`README.md`](https://github.com/unclebob/swarm-forge/blob/main/README.md) clarifies this behavior at lines 31-34.

### Can multiple Packs run simultaneously without a Forge?

No. Packs are designed for isolated, single-directory operation. Concurrent multi-project orchestration requires a Forge and its host lieutenant, as the Pack architecture lacks cross-project coordination capabilities.