pipeline

Files (1)

• SKILL.md

SKILL.md (first lines)

# Pipeline — Dynamic Multi-Agent Orchestrator

You design and execute custom multi-agent pipelines to accomplish the user's goal.

The user wants: **$ARGUMENTS**

## Prerequisites

The `factory` CLI must be installed:

```bash
command -v factory >/dev/null 2>&1 || uv tool install "${CLAUDE_PLUGIN_ROOT}"
mkdir -p .factory/pipeline
```

## Your Agents

Spawn specialists via the CLI. Each agent gets a fresh context window.

```bash
factory agent <role> --task "<task description>" --project "$(pwd)" [--timeout N]
```

| Role | Purpose |
|------|---------|
| researcher | Web research, codebase analysis, domain studies |
| strategist | Generate prioritized hypotheses from observations |
| builder | Implement code changes on a feature branch, open PRs |
| qa | Health checks, code review, adversarial QA verification |
| archivist | Record findings to `.factory/archive/` |
| distiller | Refine vague ideas into buildable specs |

### Invocation Rules

Each `factory agent` call is synchronous and blocking — it returns only when the agent finishes. Do not shell-background (`&`) individual commands.

To run steps in parallel, issue multiple `factory agent` commands as **separate bash tool calls in the same message turn**. Claude Code executes them concurrently. This is parallel tool calls, not shell backgrounding.

The runner captures agent stdout to `.factory/reviews/<role>-latest.md`.

## Phase 1: Design the Pipeline

1. **Understand the goal** — what outcome is desired? Which agents are needed?
2. **Inspect project state:**
   ```bash
   factory detect "$(pwd)"
   cat .factory/config.json 2>/dev/null
   ```
3. **Write the pipeline plan** to `.factory/pipeline/plan.md`:

```markdown
## Pipeline: <goal summary>

### Steps

| Step | Role | Task Summary | Depends On |
|------|------|-------------|-----------|
| S1 | researcher | ... | - |
| S2 | qa | ... | - |
| S3 | strategist | ... | S1, S2 |
| ... | ... | ... | ... |

### Gate Rules
- After S1: PROCEED if ...; REDIRECT if ...
- After S3: PROCEED if ...; ABORT if ...
```

### Design Principles

- **Minimize invocations** — only agents needed for this goal
- **Maximize parallelism** — steps whose dependencies are all satisfied and that don't depend on each other can be issued as parallel tool calls
- **Mandatory archival** — always include at least one archivist step at the end
- **Gate rules** — define PROCEED/REDIRECT/ABORT criteria for critical transitions

## Phase 2: Execute the Pipeline

Process steps in topological order:

1. **Identify next batch** — steps whose dependencies are all complete
2. **Build task strings** — incorporate output from prior steps by reading `.factory/reviews/<role>-latest.md`
3. **Invoke agents** — single or parallel batch
4. **Read output** — `cat .factory/reviews/<role>-latest.md`
5. **Apply gate rule:**
   - **PROCEED**: Move to next step
   - **REDIRECT**: Re-invoke with corrections (max 2 per step)
   - **ABORT**: Skip downstream steps, jump to summary
6. **Repeat** until done

### Error Recovery

- Agent timeout: retry once with shorter scope
- Agent failure: check output, decide REDIRECT or ABORT
- 2 consecutive failures: ABORT pipeline

### Final Summary

Write `.factory/pipeline/summary.md` with goal, status, step results, and key findings.

From boston-harness-group/remote-factory, MIT.

More from boston-harness-group/remote-factory