diff --git a/skills/ppg-conductor/references/commands.md b/skills/ppg-conductor/references/commands.md
index dbc01c0..c6b6c62 100644
--- a/skills/ppg-conductor/references/commands.md
+++ b/skills/ppg-conductor/references/commands.md
@@ -42,6 +42,7 @@ ppg spawn --name <name> --prompt-file /path/to/prompt.md --json --no-open
 ```
 
 **Options:**
+
 | Flag | Description |
 |------|-------------|
 | `-n, --name <name>` | Worktree/task name (default: auto-generated ID) |
@@ -195,6 +196,64 @@ ppg merge <wt-id> --force --json                   # Merge even if agents aren't
 
 Cleanup sequence: kill tmux window, teardown env, `git worktree remove --force`, `git branch -D ppg/<name>`, set manifest status `cleaned`.
 
+## ppg swarm
+
+Run a predefined swarm template — spawns multiple agents from `.pg/swarms/` with prompts from `.pg/prompts/`.
+
+```bash
+# Run a swarm template (creates new worktree, spawns all agents)
+ppg swarm code-review --var CONTEXT="Review the auth module" --json --no-open
+
+# Run a swarm against an existing worktree (e.g., review a PR's worktree)
+ppg swarm code-review --worktree wt-abc123 --var CONTEXT="Review PR #42" --json --no-open
+
+# Override worktree name
+ppg swarm code-review --name "auth-review" --var CONTEXT="Review auth changes" --json --no-open
+
+# Target by worktree name
+ppg swarm code-review --worktree feature-auth --var CONTEXT="Review auth feature" --json --no-open
+```
+
+**Options:**
+
+| Flag | Description |
+|------|-------------|
+| `-w, --worktree <ref>` | Target existing worktree by ID, name, or branch |
+| `--var <KEY=value>` | Template variable (repeatable) |
+| `-n, --name <name>` | Override worktree name (default: swarm name) |
+| `-b, --base <branch>` | Base branch for new worktree(s) |
+| `--no-open` | Suppress Terminal.app windows |
+| `--json` | JSON output |
+
+**JSON output (shared strategy):**
+```json
+{
+  "success": true,
+  "swarm": "code-review",
+  "strategy": "shared",
+  "worktree": { "id": "wt-abc123", "name": "code-review", "branch": "ppg/code-review", "path": "/path/.worktrees/wt-abc123", "tmuxWindow": "ppg-repo:1" },
+  "agents": [
+    { "id": "ag-xyz12345", "tmuxTarget": "ppg-repo:1" },
+    { "id": "ag-abc67890", "tmuxTarget": "ppg-repo:2" }
+  ]
+}
+```
+
+**Errors:** `NOT_INITIALIZED`, `INVALID_ARGS` (missing template or prompt file), `WORKTREE_NOT_FOUND`
+
+## ppg list swarms
+
+List available swarm templates.
+
+```bash
+ppg list swarms --json
+```
+
+**JSON output:**
+```json
+{ "swarms": [{ "name": "code-review", "description": "Multi-perspective code review", "strategy": "shared", "agents": 3 }] }
+```
+
 ## ppg logs
 
 View an agent's tmux pane output.
@@ -253,6 +312,7 @@ ppg wait --all --interval 10 --json      # Poll every 10s (default: 5s)
 ```
 
 **Options:**
+
 | Flag | Description |
 |------|-------------|
 | `--all` | Wait for all agents across all worktrees |
@@ -273,6 +333,7 @@ ppg send <agent-id> "C-c" --keys         # Send raw tmux keys (e.g., Ctrl-C)
 ```
 
 **Options:**
+
 | Flag | Description |
 |------|-------------|
 | `--keys` | Send raw tmux key names instead of literal text |
@@ -290,6 +351,7 @@ ppg restart <agent-id> --agent codex --json           # Override agent type
 ```
 
 **Options:**
+
 | Flag | Description |
 |------|-------------|
 | `-p, --prompt <text>` | Override the original prompt |
@@ -310,6 +372,7 @@ ppg diff <wt-id> --name-only             # Changed file names only
 ```
 
 **Options:**
+
 | Flag | Description |
 |------|-------------|
 | `--stat` | Show diffstat summary |
@@ -330,6 +393,7 @@ ppg clean --prune                        # Also run git worktree prune
 ```
 
 **Options:**
+
 | Flag | Description |
 |------|-------------|
 | `--all` | Also clean failed worktrees |
diff --git a/skills/ppg-conductor/references/conductor.md b/skills/ppg-conductor/references/conductor.md
index 780aeeb..da8bfde 100644
--- a/skills/ppg-conductor/references/conductor.md
+++ b/skills/ppg-conductor/references/conductor.md
@@ -21,7 +21,18 @@ ppg spawn --name "<name>" --prompt "<self-contained prompt>" --json --no-open
 
 **Store a tracking table** with: worktree ID, agent IDs, name, and branch for each spawned task.
 
-For swarm mode with different prompts, spawn the first agent (creates the worktree), then use `--worktree <wt-id>` for subsequent agents:
+**Swarm templates** — If a matching swarm template exists in `.pg/swarms/`, prefer `ppg swarm` over manual multi-spawn:
+```bash
+# Use a predefined swarm template (much simpler than manual spawning)
+ppg swarm code-review --var CONTEXT="Review the auth module" --json --no-open
+
+# Run a swarm against an existing worktree (e.g., review a PR's worktree)
+ppg swarm code-review --worktree wt-abc123 --var CONTEXT="Review PR #42" --json --no-open
+```
+
+Check available swarms: `ppg list swarms --json`
+
+For **custom swarm mode** (when no template matches), spawn the first agent (creates the worktree), then use `--worktree <wt-id>` for subsequent agents:
 ```bash
 # First agent — creates the worktree
 ppg spawn --name "review" --prompt "Focus on code quality..." --json --no-open
diff --git a/skills/ppg-conductor/references/modes.md b/skills/ppg-conductor/references/modes.md
index a1356f0..245aeab 100644
--- a/skills/ppg-conductor/references/modes.md
+++ b/skills/ppg-conductor/references/modes.md
@@ -13,12 +13,24 @@
 
 **Spawn patterns:**
 
-Option A — Single spawn with `--count` (same prompt, N agents):
+Option A — **Swarm template** (preferred when a matching template exists):
+```
+# Check available swarm templates
+ppg list swarms --json
+
+# Run a predefined swarm
+ppg swarm code-review --var CONTEXT="Review the auth module" --json --no-open
+
+# Run against an existing worktree
+ppg swarm code-review --worktree <wt-id> --var CONTEXT="Review PR #42" --json --no-open
+```
+
+Option B — Single spawn with `--count` (same prompt, N agents):
 ```
 ppg spawn --name "security-review" --prompt "Review for security vulnerabilities..." --count 3 --json --no-open
 ```
 
-Option B — Sequential spawns into same worktree (different prompts per agent):
+Option C — Sequential spawns into same worktree (different prompts per agent):
 ```
 # First spawn creates the worktree
 ppg spawn --name "pr-review" --prompt "Review code quality and readability..." --json --no-open
@@ -27,7 +39,7 @@ ppg spawn --worktree <wt-id> --prompt "Review for performance issues..." --json
 ppg spawn --worktree <wt-id> --prompt "Review test coverage gaps..." --json --no-open
 ```
 
-**Option B is preferred** when each agent needs a distinct prompt (which is almost always the case).
+**Option A is preferred** when a matching swarm template exists. **Option C is preferred** for custom swarm workflows where each agent needs a distinct prompt.
 
 **Post-completion:**
 1. Aggregate all results: `ppg aggregate --all --json`
diff --git a/src/bundled/prompts.ts b/src/bundled/prompts.ts
new file mode 100644
index 0000000..823bde7
--- /dev/null
+++ b/src/bundled/prompts.ts
@@ -0,0 +1,56 @@
+export const bundledPrompts: Record<string, string> = {
+  'review-quality': `# Code Quality Review
+
+## What to Review
+{{CONTEXT}}
+
+## Your Focus
+You are a senior engineer reviewing code for quality, readability, and maintainability.
+
+- Code clarity and naming conventions
+- Function and module organization
+- Error handling completeness
+- DRY violations and unnecessary complexity
+- API design and consistency
+- Documentation gaps for non-obvious logic
+
+## Output
+Write a structured review to {{RESULT_FILE}} with specific file:line references and improvement suggestions.
+`,
+  'review-security': `# Security Review
+
+## What to Review
+{{CONTEXT}}
+
+## Your Focus
+You are a security engineer reviewing code for vulnerabilities and risks.
+
+- Input validation and sanitization
+- Injection vulnerabilities (SQL, XSS, command)
+- Authentication and authorization issues
+- Sensitive data exposure
+- Dependency vulnerabilities
+- Secrets or credentials in code
+
+## Output
+Write a structured review to {{RESULT_FILE}} with severity ratings and remediation guidance.
+`,
+  'review-regression': `# Regression & Risk Review
+
+## What to Review
+{{CONTEXT}}
+
+## Your Focus
+You are a QA engineer reviewing code for regression risks and test coverage gaps.
+
+- Behavioral changes that could break existing functionality
+- Edge cases and boundary conditions not covered
+- Missing or inadequate test coverage
+- Integration points that may be affected
+- Data migration or compatibility concerns
+- Performance regressions
+
+## Output
+Write a structured review to {{RESULT_FILE}} with risk ratings and recommended test additions.
+`,
+};
diff --git a/src/bundled/swarms.ts b/src/bundled/swarms.ts
new file mode 100644
index 0000000..9fd41e7
--- /dev/null
+++ b/src/bundled/swarms.ts
@@ -0,0 +1,11 @@
+export const bundledSwarms: Record<string, string> = {
+  'code-review': `name: code-review
+description: Multi-perspective code review
+strategy: shared
+
+agents:
+  - prompt: review-quality
+  - prompt: review-security
+  - prompt: review-regression
+`,
+};
diff --git a/src/cli.ts b/src/cli.ts
index 3bd6416..b522247 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -115,10 +115,25 @@ program
     await mergeCommand(worktreeId, options);
   });
 
+program
+  .command('swarm')
+  .description('Run a swarm template — spawn multiple agents from a predefined workflow')
+  .argument('<template>', 'Swarm template name from .pg/swarms/')
+  .option('-w, --worktree <ref>', 'Target an existing worktree by ID, name, or branch')
+  .option('--var <key=value...>', 'Template variables', collectVars, [])
+  .option('-n, --name <name>', 'Override worktree name')
+  .option('-b, --base <branch>', 'Base branch for new worktree(s)')
+  .option('--no-open', 'Do not open Terminal windows')
+  .option('--json', 'Output as JSON')
+  .action(async (template, options) => {
+    const { swarmCommand } = await import('./commands/swarm.js');
+    await swarmCommand(template, options);
+  });
+
 program
   .command('list')
-  .description('List available templates')
-  .argument('<type>', 'What to list: templates')
+  .description('List available templates or swarms')
+  .argument('<type>', 'What to list: templates, swarms')
   .option('--json', 'Output as JSON')
   .action(async (type, options) => {
     const { listCommand } = await import('./commands/list.js');
diff --git a/src/commands/init.ts b/src/commands/init.ts
index 667f6b7..159114e 100644
--- a/src/commands/init.ts
+++ b/src/commands/init.ts
@@ -2,11 +2,13 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execa } from 'execa';
-import { pgDir, resultsDir, logsDir, templatesDir, promptsDir, manifestPath } from '../lib/paths.js';
+import { pgDir, resultsDir, logsDir, templatesDir, promptsDir, promptFile, swarmsDir, manifestPath } from '../lib/paths.js';
 import { NotGitRepoError, TmuxNotFoundError } from '../lib/errors.js';
 import { success, info } from '../lib/output.js';
 import { writeDefaultConfig } from '../core/config.js';
 import { createEmptyManifest, writeManifest } from '../core/manifest.js';
+import { bundledPrompts } from '../bundled/prompts.js';
+import { bundledSwarms } from '../bundled/swarms.js';
 
 const CONDUCTOR_CONTEXT = `# PPG Conductor Context
 
@@ -74,6 +76,7 @@ export async function initCommand(options: { json?: boolean }): Promise<void> {
     logsDir(projectRoot),
     templatesDir(projectRoot),
     promptsDir(projectRoot),
+    swarmsDir(projectRoot),
   ];
 
   for (const dir of dirs) {
@@ -106,12 +109,34 @@ export async function initCommand(options: { json?: boolean }): Promise<void> {
     info('Wrote sample template: default.md');
   }
 
-  // 8. Write conductor context
+  // 8. Write bundled prompt files
+  for (const [name, content] of Object.entries(bundledPrompts)) {
+    const pPath = promptFile(projectRoot, name);
+    try {
+      await fs.access(pPath);
+    } catch {
+      await fs.writeFile(pPath, content, 'utf-8');
+      info(`Wrote prompt: ${name}.md`);
+    }
+  }
+
+  // 9. Write bundled swarm templates
+  for (const [name, content] of Object.entries(bundledSwarms)) {
+    const sPath = path.join(swarmsDir(projectRoot), `${name}.yaml`);
+    try {
+      await fs.access(sPath);
+    } catch {
+      await fs.writeFile(sPath, content, 'utf-8');
+      info(`Wrote swarm template: ${name}.yaml`);
+    }
+  }
+
+  // 10. Write conductor context
   const conductorPath = path.join(pgDir(projectRoot), 'conductor-context.md');
   await fs.writeFile(conductorPath, CONDUCTOR_CONTEXT, 'utf-8');
   info('Wrote conductor-context.md');
 
-  // 9. Register Claude Code plugin
+  // 11. Register Claude Code plugin
   const pluginRegistered = await registerClaudePlugin();
   if (pluginRegistered) {
     info('Registered ppg Claude Code plugin');
@@ -186,6 +211,7 @@ async function updateGitignore(projectRoot: string): Promise<void> {
     '.pg/logs/',
     '.pg/manifest.json',
     '.pg/prompts/',
+    '.pg/swarms/',
     '.pg/conductor-context.md',
   ];
 
diff --git a/src/commands/list.ts b/src/commands/list.ts
index 266b257..d39c62e 100644
--- a/src/commands/list.ts
+++ b/src/commands/list.ts
@@ -1,8 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { getRepoRoot } from '../core/worktree.js';
-import { loadConfig } from '../core/config.js';
 import { listTemplates } from '../core/template.js';
+import { listSwarms, loadSwarm } from '../core/swarm.js';
 import { templatesDir } from '../lib/paths.js';
 import { PgError } from '../lib/errors.js';
 import { output, formatTable, type Column } from '../lib/output.js';
@@ -12,10 +12,16 @@ export interface ListOptions {
 }
 
 export async function listCommand(type: string, options: ListOptions): Promise<void> {
-  if (type !== 'templates') {
-    throw new PgError(`Unknown list type: ${type}. Available: templates`, 'INVALID_ARGS');
+  if (type === 'templates') {
+    await listTemplatesCommand(options);
+  } else if (type === 'swarms') {
+    await listSwarmsCommand(options);
+  } else {
+    throw new PgError(`Unknown list type: ${type}. Available: templates, swarms`, 'INVALID_ARGS');
   }
+}
 
+async function listTemplatesCommand(options: ListOptions): Promise<void> {
   const projectRoot = await getRepoRoot();
 
   const templateNames = await listTemplates(projectRoot);
@@ -58,3 +64,44 @@ export async function listCommand(type: string, options: ListOptions): Promise<v
 
   console.log(formatTable(templates, columns));
 }
+
+async function listSwarmsCommand(options: ListOptions): Promise<void> {
+  const projectRoot = await getRepoRoot();
+
+  const swarmNames = await listSwarms(projectRoot);
+
+  if (swarmNames.length === 0) {
+    if (options.json) {
+      output({ swarms: [] }, true);
+    } else {
+      console.log('No swarm templates found in .pg/swarms/');
+    }
+    return;
+  }
+
+  const swarms = await Promise.all(
+    swarmNames.map(async (name) => {
+      const swarm = await loadSwarm(projectRoot, name);
+      return {
+        name,
+        description: swarm.description,
+        strategy: swarm.strategy,
+        agents: swarm.agents.length,
+      };
+    }),
+  );
+
+  if (options.json) {
+    output({ swarms }, true);
+    return;
+  }
+
+  const columns: Column[] = [
+    { header: 'Name', key: 'name', width: 20 },
+    { header: 'Description', key: 'description', width: 40 },
+    { header: 'Strategy', key: 'strategy', width: 10 },
+    { header: 'Agents', key: 'agents', width: 8 },
+  ];
+
+  console.log(formatTable(swarms, columns));
+}
diff --git a/src/commands/swarm.ts b/src/commands/swarm.ts
new file mode 100644
index 0000000..1b9c1ba
--- /dev/null
+++ b/src/commands/swarm.ts
@@ -0,0 +1,344 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { loadConfig, resolveAgentConfig } from '../core/config.js';
+import { readManifest, updateManifest, resolveWorktree } from '../core/manifest.js';
+import { getRepoRoot, getCurrentBranch, createWorktree } from '../core/worktree.js';
+import { setupWorktreeEnv } from '../core/env.js';
+import { renderTemplate, type TemplateContext } from '../core/template.js';
+import { loadSwarm, type SwarmAgentEntry, type SwarmTemplate } from '../core/swarm.js';
+import { spawnAgent } from '../core/agent.js';
+import * as tmux from '../core/tmux.js';
+import { openTerminalWindow } from '../core/terminal.js';
+import { worktreeId as genWorktreeId, agentId as genAgentId, sessionId as genSessionId } from '../lib/id.js';
+import { resultFile, promptsDir, manifestPath } from '../lib/paths.js';
+import { PgError, NotInitializedError, WorktreeNotFoundError } from '../lib/errors.js';
+import { output, success, info } from '../lib/output.js';
+import type { Config } from '../types/config.js';
+import type { WorktreeEntry, AgentEntry } from '../types/manifest.js';
+
+export interface SwarmOptions {
+  worktree?: string;
+  var?: string[];
+  name?: string;
+  base?: string;
+  open?: boolean;
+  json?: boolean;
+}
+
+export async function swarmCommand(templateName: string, options: SwarmOptions): Promise<void> {
+  const projectRoot = await getRepoRoot();
+  const config = await loadConfig(projectRoot);
+
+  // Verify initialized
+  try {
+    await fs.access(manifestPath(projectRoot));
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+
+  // Load swarm template
+  const swarm = await loadSwarm(projectRoot, templateName);
+
+  // Parse user vars
+  const userVars = parseVars(options.var ?? []);
+
+  if (options.worktree) {
+    await swarmIntoExistingWorktree(projectRoot, config, swarm, options, userVars);
+  } else if (swarm.strategy === 'isolated') {
+    await swarmIsolated(projectRoot, config, swarm, options, userVars);
+  } else {
+    await swarmShared(projectRoot, config, swarm, options, userVars);
+  }
+}
+
+function parseVars(vars: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const v of vars) {
+    const eqIdx = v.indexOf('=');
+    if (eqIdx < 1) {
+      throw new PgError(`Invalid --var format: "${v}" — expected KEY=value`, 'INVALID_ARGS');
+    }
+    result[v.slice(0, eqIdx)] = v.slice(eqIdx + 1);
+  }
+  return result;
+}
+
+async function loadPromptFile(projectRoot: string, promptName: string): Promise<string> {
+  const filePath = path.join(promptsDir(projectRoot), `${promptName}.md`);
+  try {
+    return await fs.readFile(filePath, 'utf-8');
+  } catch {
+    throw new PgError(`Prompt file not found: ${promptName}.md in .pg/prompts/`, 'INVALID_ARGS');
+  }
+}
+
+interface SpawnSwarmAgentOptions {
+  projectRoot: string;
+  config: Config;
+  swarmAgent: SwarmAgentEntry;
+  wtPath: string;
+  branchName: string;
+  tmuxTarget: string;
+  taskName: string;
+  userVars: Record<string, string>;
+}
+
+async function spawnSwarmAgent(opts: SpawnSwarmAgentOptions): Promise<AgentEntry> {
+  const { projectRoot, config, swarmAgent, wtPath, branchName, tmuxTarget, taskName, userVars } = opts;
+  const agentConfig = resolveAgentConfig(config, swarmAgent.agent);
+  const aId = genAgentId();
+
+  const promptContent = await loadPromptFile(projectRoot, swarmAgent.prompt);
+  const ctx: TemplateContext = {
+    WORKTREE_PATH: wtPath,
+    BRANCH: branchName,
+    AGENT_ID: aId,
+    RESULT_FILE: resultFile(projectRoot, aId),
+    PROJECT_ROOT: projectRoot,
+    TASK_NAME: taskName,
+    ...(swarmAgent.vars ?? {}),
+    ...userVars,
+  };
+  const renderedPrompt = renderTemplate(promptContent, ctx);
+
+  return spawnAgent({
+    agentId: aId,
+    agentConfig,
+    prompt: renderedPrompt,
+    worktreePath: wtPath,
+    tmuxTarget,
+    projectRoot,
+    branch: branchName,
+    sessionId: genSessionId(),
+  });
+}
+
+async function swarmShared(
+  projectRoot: string,
+  config: Config,
+  swarm: SwarmTemplate,
+  options: SwarmOptions,
+  userVars: Record<string, string>,
+): Promise<void> {
+  const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
+  const wtId = genWorktreeId();
+  const name = options.name ?? swarm.name;
+  const branchName = `ppg/${name}`;
+
+  info(`Creating worktree ${wtId} on branch ${branchName}`);
+  const wtPath = await createWorktree(projectRoot, wtId, {
+    branch: branchName,
+    base: baseBranch,
+  });
+
+  await setupWorktreeEnv(projectRoot, wtPath, config);
+
+  const sessionName = config.sessionName;
+  await tmux.ensureSession(sessionName);
+  const windowTarget = await tmux.createWindow(sessionName, name, wtPath);
+
+  // Register worktree in manifest before spawning agents so partial failures are tracked
+  await updateManifest(projectRoot, (m) => {
+    m.worktrees[wtId] = {
+      id: wtId,
+      name,
+      path: wtPath,
+      branch: branchName,
+      baseBranch,
+      status: 'active',
+      tmuxWindow: windowTarget,
+      agents: {},
+      createdAt: new Date().toISOString(),
+    };
+    return m;
+  });
+
+  const agents: AgentEntry[] = [];
+  for (let i = 0; i < swarm.agents.length; i++) {
+    const target = i === 0
+      ? windowTarget
+      : await tmux.createWindow(sessionName, `${name}-${i}`, wtPath);
+
+    const agentEntry = await spawnSwarmAgent({
+      projectRoot, config, swarmAgent: swarm.agents[i],
+      wtPath, branchName, tmuxTarget: target, taskName: name, userVars,
+    });
+    agents.push(agentEntry);
+
+    await updateManifest(projectRoot, (m) => {
+      m.worktrees[wtId].agents[agentEntry.id] = agentEntry;
+      return m;
+    });
+  }
+
+  if (options.open !== false) {
+    openTerminalWindow(sessionName, windowTarget, name).catch(() => {});
+  }
+
+  outputResult(options.json, swarm, wtId, name, branchName, wtPath, windowTarget, agents);
+}
+
+async function swarmIsolated(
+  projectRoot: string,
+  config: Config,
+  swarm: SwarmTemplate,
+  options: SwarmOptions,
+  userVars: Record<string, string>,
+): Promise<void> {
+  const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
+  const baseName = options.name ?? swarm.name;
+  const sessionName = config.sessionName;
+  await tmux.ensureSession(sessionName);
+
+  const worktrees: Array<{ id: string; name: string; branch: string; path: string; tmuxWindow: string }> = [];
+  const allAgents: AgentEntry[] = [];
+
+  const usedNames = new Set<string>();
+  for (const swarmAgent of swarm.agents) {
+    const wtId = genWorktreeId();
+    let wtName = `${baseName}-${swarmAgent.prompt}`;
+    if (usedNames.has(wtName)) {
+      let suffix = 2;
+      while (usedNames.has(`${wtName}-${suffix}`)) suffix++;
+      wtName = `${wtName}-${suffix}`;
+    }
+    usedNames.add(wtName);
+    const branchName = `ppg/${wtName}`;
+
+    info(`Creating worktree ${wtId} on branch ${branchName}`);
+    const wtPath = await createWorktree(projectRoot, wtId, {
+      branch: branchName,
+      base: baseBranch,
+    });
+
+    await setupWorktreeEnv(projectRoot, wtPath, config);
+    const windowTarget = await tmux.createWindow(sessionName, wtName, wtPath);
+
+    const agentEntry = await spawnSwarmAgent({
+      projectRoot, config, swarmAgent,
+      wtPath, branchName, tmuxTarget: windowTarget, taskName: wtName, userVars,
+    });
+
+    const worktreeEntry: WorktreeEntry = {
+      id: wtId,
+      name: wtName,
+      path: wtPath,
+      branch: branchName,
+      baseBranch,
+      status: 'active',
+      tmuxWindow: windowTarget,
+      agents: { [agentEntry.id]: agentEntry },
+      createdAt: new Date().toISOString(),
+    };
+
+    await updateManifest(projectRoot, (m) => {
+      m.worktrees[wtId] = worktreeEntry;
+      return m;
+    });
+
+    if (options.open !== false) {
+      openTerminalWindow(sessionName, windowTarget, wtName).catch(() => {});
+    }
+
+    worktrees.push({ id: wtId, name: wtName, branch: branchName, path: wtPath, tmuxWindow: windowTarget });
+    allAgents.push(agentEntry);
+  }
+
+  if (options.json) {
+    output({
+      success: true,
+      swarm: swarm.name,
+      strategy: 'isolated',
+      worktrees: worktrees.map((wt, i) => ({
+        ...wt,
+        agents: [{ id: allAgents[i].id, tmuxTarget: allAgents[i].tmuxTarget, sessionId: allAgents[i].sessionId }],
+      })),
+    }, true);
+  } else {
+    success(`Swarm "${swarm.name}" spawned ${swarm.agents.length} agent(s) in isolated worktrees`);
+    for (let i = 0; i < worktrees.length; i++) {
+      info(`  ${worktrees[i].name} (${worktrees[i].id}) → agent ${allAgents[i].id}`);
+    }
+  }
+}
+
+async function swarmIntoExistingWorktree(
+  projectRoot: string,
+  config: Config,
+  swarm: SwarmTemplate,
+  options: SwarmOptions,
+  userVars: Record<string, string>,
+): Promise<void> {
+  const manifest = await readManifest(projectRoot);
+  const wt = resolveWorktree(manifest, options.worktree!);
+
+  if (!wt) throw new WorktreeNotFoundError(options.worktree!);
+
+  const sessionName = config.sessionName;
+
+  // Lazily create tmux window if worktree has none
+  let windowTarget = wt.tmuxWindow;
+  if (!windowTarget) {
+    await tmux.ensureSession(sessionName);
+    windowTarget = await tmux.createWindow(sessionName, wt.name, wt.path);
+  }
+
+  // Update tmux window before spawning so partial failures are tracked
+  if (!wt.tmuxWindow) {
+    await updateManifest(projectRoot, (m) => {
+      m.worktrees[wt.id].tmuxWindow = windowTarget;
+      return m;
+    });
+  }
+
+  const agents: AgentEntry[] = [];
+  for (let i = 0; i < swarm.agents.length; i++) {
+    const target = i === 0
+      ? windowTarget
+      : await tmux.createWindow(sessionName, `${wt.name}-${swarm.name}-${i}`, wt.path);
+
+    const agentEntry = await spawnSwarmAgent({
+      projectRoot, config, swarmAgent: swarm.agents[i],
+      wtPath: wt.path, branchName: wt.branch, tmuxTarget: target, taskName: wt.name, userVars,
+    });
+    agents.push(agentEntry);
+
+    await updateManifest(projectRoot, (m) => {
+      m.worktrees[wt.id].agents[agentEntry.id] = agentEntry;
+      return m;
+    });
+  }
+
+  if (options.open !== false) {
+    openTerminalWindow(sessionName, windowTarget, wt.name).catch(() => {});
+  }
+
+  outputResult(options.json, swarm, wt.id, wt.name, wt.branch, wt.path, windowTarget, agents);
+}
+
+function outputResult(
+  json: boolean | undefined,
+  swarm: SwarmTemplate,
+  wtId: string,
+  name: string,
+  branch: string,
+  wtPath: string,
+  tmuxWindow: string,
+  agents: AgentEntry[],
+): void {
+  if (json) {
+    output({
+      success: true,
+      swarm: swarm.name,
+      strategy: swarm.strategy,
+      worktree: { id: wtId, name, branch, path: wtPath, tmuxWindow },
+      agents: agents.map((a) => ({ id: a.id, tmuxTarget: a.tmuxTarget, sessionId: a.sessionId })),
+    }, true);
+  } else {
+    success(`Swarm "${swarm.name}" spawned ${agents.length} agent(s) in worktree ${wtId}`);
+    for (const a of agents) {
+      info(`  Agent ${a.id} → ${a.tmuxTarget}`);
+    }
+    info(`Attach: ppg attach ${wtId}`);
+  }
+}
diff --git a/src/core/swarm.test.ts b/src/core/swarm.test.ts
new file mode 100644
index 0000000..22c8a1f
--- /dev/null
+++ b/src/core/swarm.test.ts
@@ -0,0 +1,276 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+import { listSwarms, loadSwarm } from './swarm.js';
+
+const TMP_ROOT = path.join(process.cwd(), '.test-tmp-swarm');
+const SWARMS_DIR = path.join(TMP_ROOT, '.pg', 'swarms');
+
+beforeEach(async () => {
+  await fs.mkdir(SWARMS_DIR, { recursive: true });
+});
+
+afterEach(async () => {
+  await fs.rm(TMP_ROOT, { recursive: true, force: true });
+});
+
+const validYaml = `name: code-review
+description: Multi-perspective code review
+strategy: shared
+
+agents:
+  - prompt: review-quality
+  - prompt: review-security
+`;
+
+describe('listSwarms', () => {
+  test('given a directory with .yaml files, should return names without extension', async () => {
+    await fs.writeFile(path.join(SWARMS_DIR, 'code-review.yaml'), validYaml);
+    await fs.writeFile(path.join(SWARMS_DIR, 'deploy.yaml'), validYaml);
+
+    const actual = await listSwarms(TMP_ROOT);
+
+    expect(actual).toHaveLength(2);
+    expect(actual).toEqual(expect.arrayContaining(['code-review', 'deploy']));
+  });
+
+  test('given a directory with .yml files, should return names without extension', async () => {
+    await fs.writeFile(path.join(SWARMS_DIR, 'legacy.yml'), validYaml);
+
+    const actual = await listSwarms(TMP_ROOT);
+
+    expect(actual).toEqual(['legacy']);
+  });
+
+  test('given a directory with mixed yaml and non-yaml files, should only return yaml files', async () => {
+    await fs.writeFile(path.join(SWARMS_DIR, 'good.yaml'), validYaml);
+    await fs.writeFile(path.join(SWARMS_DIR, 'readme.md'), '# README');
+    await fs.writeFile(path.join(SWARMS_DIR, 'notes.txt'), 'notes');
+
+    const actual = await listSwarms(TMP_ROOT);
+
+    expect(actual).toEqual(['good']);
+  });
+
+  test('given a nonexistent swarms directory, should return empty array', async () => {
+    await fs.rm(SWARMS_DIR, { recursive: true, force: true });
+
+    const actual = await listSwarms(TMP_ROOT);
+
+    expect(actual).toEqual([]);
+  });
+
+  test('given an empty directory, should return empty array', async () => {
+    const actual = await listSwarms(TMP_ROOT);
+
+    expect(actual).toEqual([]);
+  });
+});
+
+describe('loadSwarm', () => {
+  test('given valid YAML with .yaml extension, should parse correctly', async () => {
+    await fs.writeFile(path.join(SWARMS_DIR, 'code-review.yaml'), validYaml);
+
+    const actual = await loadSwarm(TMP_ROOT, 'code-review');
+
+    expect(actual).toEqual({
+      name: 'code-review',
+      description: 'Multi-perspective code review',
+      strategy: 'shared',
+      agents: [
+        { prompt: 'review-quality' },
+        { prompt: 'review-security' },
+      ],
+    });
+  });
+
+  test('given valid YAML with .yml extension, should fall back and parse', async () => {
+    await fs.writeFile(path.join(SWARMS_DIR, 'legacy.yml'), validYaml);
+
+    const actual = await loadSwarm(TMP_ROOT, 'legacy');
+
+    expect(actual.name).toBe('code-review');
+    expect(actual.agents).toHaveLength(2);
+  });
+
+  test('given no strategy field, should default to shared', async () => {
+    const yaml = `name: test-swarm
+agents:
+  - prompt: review-quality
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'test-swarm.yaml'), yaml);
+
+    const actual = await loadSwarm(TMP_ROOT, 'test-swarm');
+
+    expect(actual.strategy).toBe('shared');
+  });
+
+  test('given no description field, should default to empty string', async () => {
+    const yaml = `name: test-swarm
+agents:
+  - prompt: review-quality
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'test-swarm.yaml'), yaml);
+
+    const actual = await loadSwarm(TMP_ROOT, 'test-swarm');
+
+    expect(actual.description).toBe('');
+  });
+
+  test('given isolated strategy, should accept it', async () => {
+    const yaml = `name: test-swarm
+strategy: isolated
+agents:
+  - prompt: review-quality
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'test-swarm.yaml'), yaml);
+
+    const actual = await loadSwarm(TMP_ROOT, 'test-swarm');
+
+    expect(actual.strategy).toBe('isolated');
+  });
+
+  test('given agent with optional overrides, should preserve them', async () => {
+    const yaml = `name: test-swarm
+agents:
+  - prompt: review-quality
+    agent: codex
+    vars:
+      EXTRA: "be thorough"
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'test-swarm.yaml'), yaml);
+
+    const actual = await loadSwarm(TMP_ROOT, 'test-swarm');
+
+    expect(actual.agents[0]).toEqual({
+      prompt: 'review-quality',
+      agent: 'codex',
+      vars: { EXTRA: 'be thorough' },
+    });
+  });
+
+  test('given empty YAML file, should throw INVALID_ARGS', async () => {
+    await fs.writeFile(path.join(SWARMS_DIR, 'empty.yaml'), '');
+
+    await expect(loadSwarm(TMP_ROOT, 'empty'))
+      .rejects.toThrow('empty or malformed YAML');
+  });
+
+  test('given nonexistent template, should throw INVALID_ARGS', async () => {
+    await expect(loadSwarm(TMP_ROOT, 'nope'))
+      .rejects.toThrow('Swarm template not found: nope');
+  });
+
+  test('given YAML missing name field, should throw INVALID_ARGS', async () => {
+    const yaml = `agents:
+  - prompt: review-quality
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'bad.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'bad'))
+      .rejects.toThrow('missing name or agents');
+  });
+
+  test('given YAML missing agents field, should throw INVALID_ARGS', async () => {
+    const yaml = `name: test-swarm
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'bad.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'bad'))
+      .rejects.toThrow('missing name or agents');
+  });
+
+  test('given invalid strategy, should throw INVALID_ARGS', async () => {
+    const yaml = `name: test-swarm
+strategy: parallel
+agents:
+  - prompt: review-quality
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'bad.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'bad'))
+      .rejects.toThrow("Must be 'shared' or 'isolated'");
+  });
+
+  test('given agent missing prompt field, should throw INVALID_ARGS', async () => {
+    const yaml = `name: test-swarm
+agents:
+  - agent: claude
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'bad.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'bad'))
+      .rejects.toThrow('agent[0] missing prompt field');
+  });
+
+  test('given agent with path traversal in prompt name, should throw INVALID_ARGS', async () => {
+    const yaml = `name: test-swarm
+agents:
+  - prompt: "../../etc/passwd"
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'bad.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'bad'))
+      .rejects.toThrow('must be alphanumeric, hyphens, or underscores');
+  });
+
+  test('given agent with slash in prompt name, should throw INVALID_ARGS', async () => {
+    const yaml = `name: test-swarm
+agents:
+  - prompt: "sub/dir"
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'bad.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'bad'))
+      .rejects.toThrow('must be alphanumeric, hyphens, or underscores');
+  });
+
+  test('given agent with underscores and hyphens in prompt name, should accept', async () => {
+    const yaml = `name: test-swarm
+agents:
+  - prompt: review_quality-v2
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'test-swarm.yaml'), yaml);
+
+    const actual = await loadSwarm(TMP_ROOT, 'test-swarm');
+
+    expect(actual.agents[0].prompt).toBe('review_quality-v2');
+  });
+
+  test('given template name with path traversal, should throw INVALID_ARGS', async () => {
+    await expect(loadSwarm(TMP_ROOT, '../../etc/passwd'))
+      .rejects.toThrow('Invalid swarm template name');
+  });
+
+  test('given template name with slashes, should throw INVALID_ARGS', async () => {
+    await expect(loadSwarm(TMP_ROOT, 'sub/dir'))
+      .rejects.toThrow('Invalid swarm template name');
+  });
+
+  test('given template name with spaces, should throw INVALID_ARGS', async () => {
+    await expect(loadSwarm(TMP_ROOT, 'bad name'))
+      .rejects.toThrow('Invalid swarm template name');
+  });
+
+  test('given YAML with unsafe swarm name, should throw INVALID_ARGS', async () => {
+    const yaml = `name: "../../bad"
+agents:
+  - prompt: review-quality
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'sneaky.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'sneaky'))
+      .rejects.toThrow('Invalid swarm name');
+  });
+
+  test('given YAML with spaces in swarm name, should throw INVALID_ARGS', async () => {
+    const yaml = `name: "bad name"
+agents:
+  - prompt: review-quality
+`;
+    await fs.writeFile(path.join(SWARMS_DIR, 'bad-name.yaml'), yaml);
+
+    await expect(loadSwarm(TMP_ROOT, 'bad-name'))
+      .rejects.toThrow('Invalid swarm name');
+  });
+});
diff --git a/src/core/swarm.ts b/src/core/swarm.ts
new file mode 100644
index 0000000..d774965
--- /dev/null
+++ b/src/core/swarm.ts
@@ -0,0 +1,105 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { swarmsDir } from '../lib/paths.js';
+import { PgError } from '../lib/errors.js';
+
+export interface SwarmAgentEntry {
+  prompt: string;
+  agent?: string;
+  vars?: Record<string, string>;
+}
+
+export interface SwarmTemplate {
+  name: string;
+  description: string;
+  strategy: 'shared' | 'isolated';
+  agents: SwarmAgentEntry[];
+}
+
+const SAFE_NAME = /^[\w-]+$/;
+
+export async function listSwarms(projectRoot: string): Promise<string[]> {
+  const dir = swarmsDir(projectRoot);
+  try {
+    const files = await fs.readdir(dir);
+    return files
+      .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
+      .map((f) => f.replace(/\.ya?ml$/, ''))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+export async function loadSwarm(projectRoot: string, name: string): Promise<SwarmTemplate> {
+  if (!SAFE_NAME.test(name)) {
+    throw new PgError(
+      `Invalid swarm template name: "${name}" — must be alphanumeric, hyphens, or underscores`,
+      'INVALID_ARGS',
+    );
+  }
+
+  const dir = swarmsDir(projectRoot);
+
+  // Try .yaml first, then .yml
+  let filePath = path.join(dir, `${name}.yaml`);
+  try {
+    await fs.access(filePath);
+  } catch {
+    filePath = path.join(dir, `${name}.yml`);
+    try {
+      await fs.access(filePath);
+    } catch {
+      throw new PgError(`Swarm template not found: ${name}`, 'INVALID_ARGS');
+    }
+  }
+
+  const raw = await fs.readFile(filePath, 'utf-8');
+  const parsed = YAML.parse(raw) as SwarmTemplate;
+
+  if (!parsed || typeof parsed !== 'object') {
+    throw new PgError(`Invalid swarm template: ${name} (empty or malformed YAML)`, 'INVALID_ARGS');
+  }
+
+  if (!parsed.name || !parsed.agents || !Array.isArray(parsed.agents)) {
+    throw new PgError(`Invalid swarm template: ${name} (missing name or agents)`, 'INVALID_ARGS');
+  }
+
+  if (!SAFE_NAME.test(parsed.name)) {
+    throw new PgError(
+      `Invalid swarm name: "${parsed.name}" — must be alphanumeric, hyphens, or underscores`,
+      'INVALID_ARGS',
+    );
+  }
+
+  if (parsed.strategy && parsed.strategy !== 'shared' && parsed.strategy !== 'isolated') {
+    throw new PgError(
+      `Invalid swarm strategy: ${parsed.strategy}. Must be 'shared' or 'isolated'`,
+      'INVALID_ARGS',
+    );
+  }
+
+  // Validate each agent has a valid prompt name
+  for (let i = 0; i < parsed.agents.length; i++) {
+    const agent = parsed.agents[i];
+    if (!agent.prompt || typeof agent.prompt !== 'string') {
+      throw new PgError(
+        `Invalid swarm template: ${name} — agent[${i}] missing prompt field`,
+        'INVALID_ARGS',
+      );
+    }
+    if (!SAFE_NAME.test(agent.prompt)) {
+      throw new PgError(
+        `Invalid prompt name: "${agent.prompt}" — must be alphanumeric, hyphens, or underscores`,
+        'INVALID_ARGS',
+      );
+    }
+  }
+
+  return {
+    ...parsed,
+    strategy: parsed.strategy ?? 'shared',
+    description: parsed.description ?? '',
+  };
+}
diff --git a/src/lib/paths.ts b/src/lib/paths.ts
index ea6ec88..5f152b8 100644
--- a/src/lib/paths.ts
+++ b/src/lib/paths.ts
@@ -34,6 +34,10 @@ export function promptsDir(projectRoot: string): string {
   return path.join(pgDir(projectRoot), 'prompts');
 }
 
+export function swarmsDir(projectRoot: string): string {
+  return path.join(pgDir(projectRoot), 'swarms');
+}
+
 export function promptFile(projectRoot: string, agentId: string): string {
   return path.join(promptsDir(projectRoot), `${agentId}.md`);
 }