Lobbi-Docs 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.