Agentic Patterns

13 patterns from Anthropic's workflow/agent taxonomy + Andrew Ng's four foundational patterns. This skill is the router; templates live in MCP cc_kb_pattern_template(name) and the pattern-router agent picks for you.

Choose by task shape

How many distinct phases?
│
├─ 1 (single generation) ──────────────► REFLECTION
│
├─ 2-4 (sequential, each uses prior) ──► PROMPT CHAINING
│
├─ 2-4 (independent, same question) ───► PARALLELIZATION
│
├─ Branching on input type ────────────► ROUTING
│
├─ Quality must meet a rubric ─────────► EVALUATOR-OPTIMIZER
│
├─ Emergent subtasks, dynamic ─────────► ORCHESTRATOR-WORKERS
│
├─ Open debug / root-cause ────────────► ReAct (thought→action→observation)
│
├─ Multi-agent collaborative review ───► BLACKBOARD (council)
│
└─ Unsure? ────────────────────────────► use agents/cc-pattern-router

Pattern quick-reference

Pattern	Cost	Best for	Template
Reflection	1.1×	Default quality gate on single shots	`cc_kb_pattern_template("reflection")`
Prompt chaining	1.5–2×	Multi-phase features (analyze→plan→implement→verify)	`cc_kb_pattern_template("prompt-chaining")`
Routing	1×	Task-type decides the branch	`cc_kb_pattern_template("routing")`
Parallelization	1–3×	Independent parallel subtasks, fan-in synthesis	`cc_kb_pattern_template("parallelization")`
Evaluator-optimizer	1.5–3×	Quality-critical artifacts (configs, security code)	`cc_kb_pattern_template("eval-optimizer")`
Orchestrator-workers	2–5×	Large features where subtasks emerge during work	`cc_kb_pattern_template("orchestrator-workers")`
ReAct	1.2–2×	Open-ended debugging, exploration	`cc_kb_pattern_template("react")`
Blackboard	3–6×	Multi-agent collaborative review/synthesis	`cc_kb_pattern_template("blackboard")`

Wiring patterns into the 5-layer stack

Each pattern deploys artifacts across layers. Example for reflection:

Layer	Artifact
L1 — CLAUDE.md	Add rule: "Review your own output before presenting. Check for off-by-one errors, unhandled edge cases, and inconsistency with existing code patterns."
L2 — Skill	None required — behavior driven from CLAUDE.md
L3 — Hook	Optional: PostToolUse on Write
L4 — Agent	`agents/cc-audit-reviewer` for explicit second-pass when risk is high
L5 — Memory	Save rejection reasons to engram for learning

Fetch a specific pattern's full wiring via cc_kb_pattern_template(name).

Pattern selection via router agent

When the task is ambiguous, launch pattern-router:

Agent({
  subagent_type: "pattern-router",
  prompt: "Task: {...}. Select the optimal agentic pattern with rationale."
})

Router returns: pattern name + 5-layer wiring + cost estimate + anti-patterns.

MCP delegation

Need	Tool
Fetch pattern template	`cc_kb_pattern_template(name)`
Decide orchestration cost cap	`cc_docs_model_recommend(task, budget)`
Recommend topology for multi-agent	`cc_docs_team_topology_recommend(task, complexity, team_size)`

Parallelization vs Blackboard — when each applies

Both fan out to multiple agents. The difference is whether agents read each other's work:

	Parallelization	Blackboard
Agents see peers?	No — each gets only their scope	Yes — each reads the shared board before writing
Subtasks	Fully independent	Overlapping; one agent's finding informs another
Example	Run security + perf + test reviews simultaneously	Security agent flags an issue; architecture agent reads it and re-evaluates their finding
Cost	1–3×	3–6× (extra rounds per agent)
When to choose	Subtasks have zero shared state	Agents must build on each other's output (adversarial or consensus-building)

If in doubt: start with parallelization. Upgrade to blackboard only when a second round of cross-agent reasoning is demonstrably necessary.

Anti-patterns

Using eval-optimizer for simple tasks → wasted loops, no quality gain.
Parallelization when subtasks share state → merge conflicts and hallucinated consistency.
Orchestrator-workers for fixed-scope work → supervisor overhead dominates.
ReAct with no stopping criterion → runs forever on fuzzy tasks.
Blackboard with fewer than 3 agents → not actually multi-agent; just a chain with extra steps.

cc-agentic-patterns