6.8 KiB

Raw Blame History

Pipeline Orchestrator

Overview

The Pipeline Orchestrator enables multi-stage agent pipelines with automatic dependency management. It supports sequential, parallel, and hybrid execution modes.

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                      PIPELINE ORCHESTRATOR                          │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   ┌─────────┐    ┌─────────┐    ┌─────────┐                        │
│   │ Stage 1 │───▶│ Stage 2 │───▶│ Stage 3 │  (Sequential)          │
│   └─────────┘    └─────────┘    └─────────┘                        │
│                                                                     │
│   ┌─────────┐                                                       │
│   │ Stage A │─┐                                                     │
│   └─────────┘ │  ┌─────────┐                                       │
│               ├─▶│ Stage D │  (Parallel → Sequential)              │
│   ┌─────────┐ │  └─────────┘                                       │
│   │ Stage B │─┘                                                     │
│   └─────────┘                                                       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Commands

PIPELINE create

Create a new pipeline from template or custom definition.

PIPELINE create
PIPELINE create --template full_sdlc
PIPELINE create --name "Custom Pipeline"

PIPELINE run

Execute a pipeline.

PIPELINE run PIPE-20250115-myproject
PIPELINE run --active

PIPELINE status

Show pipeline status.

PIPELINE status
PIPELINE status PIPE-20250115-myproject

Example output:

Pipeline: PIPE-20250115-myproject
Status: running
Progress: [████████░░░░░░░░░░░░] 40%

Stages:
[✓] analysis
    Agents: analyst
    Duration: 12m 34s
    Output: pipelines/outputs/analysis/

[✓] requirements
    Agents: pm
    Duration: 18m 22s
    Output: pipelines/outputs/requirements/

[►] design
    Agents: architect, ux-designer (parallel)
    Duration: 8m 15s (running)
    Output: pending

[○] planning
    Agents: sm
    Duration: pending
    Output: n/a

Currently executing: design
Estimated remaining: ~45 minutes

PIPELINE list

List available pipelines and templates.

PIPELINE list

PIPELINE abort

Abort a running pipeline.

PIPELINE abort PIPE-20250115-myproject

PIPELINE resume

Resume a failed or paused pipeline.

PIPELINE resume PIPE-20250115-myproject

Pipeline Templates

full_sdlc

Complete software development lifecycle.

stages:
  - analysis (analyst)
  - requirements (pm) → depends on analysis
  - design (architect + ux-designer, parallel) → depends on requirements
  - planning (sm) → depends on design
  - implementation (dev) → depends on planning
  - review (tea) → depends on implementation

quick_flow

Rapid development with minimal ceremony.

stages:
  - spec (quick-flow-solo-dev)
  - implement (quick-flow-solo-dev) → depends on spec

analysis_only

Product analysis and requirements.

stages:
  - research (analyst)
  - brief (analyst) → depends on research
  - requirements (pm) → depends on brief

design_review

Architecture and UX design with review.

stages:
  - architecture (architect)
  - ux (ux-designer) → depends on architecture
  - review (analyst + pm, parallel) → depends on architecture, ux

test_suite

Comprehensive testing workflow.

stages:
  - test_design (tea)
  - test_impl (tea) → depends on test_design
  - security (tea) → depends on test_impl
  - trace (tea) → depends on test_impl

Custom Pipeline Definition

pipeline_id: "PIPE-20250115-custom"
name: "Custom Pipeline"
description: "My custom pipeline"
created: "2025-01-15T10:00:00Z"
status: "pending"

stages:
  - name: "stage1"
    agents: ["analyst"]
    parallel: false
    depends_on: []
    outputs: ["analysis_report"]
    status: "pending"

  - name: "stage2"
    agents: ["architect", "ux-designer"]
    parallel: true
    depends_on: ["stage1"]
    outputs: ["architecture", "ux_design"]
    status: "pending"

  - name: "stage3"
    agents: ["dev"]
    parallel: false
    depends_on: ["stage2"]
    outputs: ["implementation"]
    status: "pending"

Execution Flow

Initialize: Load pipeline definition, validate agents exist
Queue: Find stages with all dependencies completed
Execute: Run queued stages (parallel or sequential based on config)
Collect: Gather outputs from completed stages
Update: Update pipeline state file
Repeat: Continue until all stages complete or failure

Error Handling

Mode	Behavior
halt	Stop pipeline on first failure
skip_dependents	Skip stages that depend on failed stage
retry	Retry failed stage (up to max_retries)

Output Management

Pipeline outputs are stored in:

_bmad-output/
└── pipelines/
    ├── PIPE-20250115-myproject.yaml  # Pipeline state
    └── outputs/
        ├── analysis/
        │   └── product-brief.md
        ├── requirements/
        │   └── prd.md
        └── design/
            ├── architecture.md
            └── ux-design.md

Integration with Token Isolation

When executing stages:

Each agent runs in isolated subprocess (via Task tool)
Outputs written to pipeline output directory
Only status summaries return to orchestrator
Token budget preserved across multi-stage pipelines

Best Practices

Use templates for common workflows
Define dependencies explicitly for correct execution order
Enable parallel only for truly independent stages
Monitor progress with status command
Archive completed pipelines to maintain clean state

6.8 KiB Raw Blame History