AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

task-coordination-strategies

Decompose complex tasks, design dependency graphs, and coordinate multi-agent work with proper task descriptions and workload balancing. Use this skill when breaking down work for agent teams, managing task dependencies, or monitoring team progress.

Original source
wshobson
License
MIT
Pinned revision
7e2fb559cf4b824b27f1fec49fe88f7511066d26

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

Ask your assistant

Use Agentic Memory skills to read wshobson--task-coordination-strategies at revision 7e2fb559cf4b824b27f1fec49fe88f7511066d26, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 3

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.