agents/plugins/agent-teams/skills/task-coordination-strategies/references/dependency-graphs.md

Dependency Graph Patterns

Visual patterns for task dependency design with trade-offs.

Pattern 1: Fully Independent (Maximum Parallelism)

Task A ─┐
Task B ─┼─→ Final Integration
Task C ─┘

• Parallelism: Maximum — all tasks run simultaneously
• Risk: Integration may reveal incompatibilities late
• Use when: Tasks operate on completely separate files/modules
• TaskCreate: No blockedBy relationships; integration task blocked by all

Pattern 2: Sequential Chain (No Parallelism)

Task A → Task B → Task C → Task D

• Parallelism: None — each task waits for the previous
• Risk: Bottleneck at each step; one delay cascades
• Use when: Each task depends on the output of the previous (avoid if possible)
• TaskCreate: Each task blockedBy the previous

Pattern 3: Diamond (Shared Foundation)

           ┌→ Task B ─┐
Task A ──→ ┤          ├→ Task D
           └→ Task C ─┘

• Parallelism: B and C run in parallel after A completes
• Risk: A is a bottleneck; D must wait for both B and C
• Use when: B and C both need output from A (e.g., shared types)
• TaskCreate: B and C blockedBy A; D blockedBy B and C

Pattern 4: Fork-Join (Phased Parallelism)

Phase 1:  A1, A2, A3  (parallel)
          ────────────
Phase 2:  B1, B2      (parallel, after phase 1)
          ────────────
Phase 3:  C1          (after phase 2)

• Parallelism: Within each phase, tasks are parallel
• Risk: Phase boundaries add synchronization delays
• Use when: Natural phases with dependencies (build → test → deploy)
• TaskCreate: Phase 2 tasks blockedBy all Phase 1 tasks

Pattern 5: Pipeline (Streaming)

Task A ──→ Task B ──→ Task C
  └──→ Task D ──→ Task E

• Parallelism: Two parallel chains
• Risk: Chains may diverge in approach
• Use when: Two independent feature branches from a common starting point
• TaskCreate: B blockedBy A; D blockedBy A; C blockedBy B; E blockedBy D

Anti-Patterns

Circular Dependency (Deadlock)

Task A → Task B → Task C → Task A  ✗ DEADLOCK

Fix: Extract shared dependency into a separate task that all three depend on.

Unnecessary Dependencies

Task A → Task B → Task C
(where B doesn't actually need A's output)

Fix: Remove the blockedBy relationship; let B run independently.

Star Pattern (Single Bottleneck)

     ┌→ B
A →  ├→ C  → F
     ├→ D
     └→ E

Fix: If A is slow, all downstream tasks are delayed. Try to parallelize A's work.