wicked-garden-agentic-agentic-patterns git:20260424.1fce5c1A

Immutable. This exact content never changes and is served at /api/v1/blob/5d48bf3dc940b800.

---
name: agentic-patterns
description: |
  Use when designing or analyzing multi-agent architectures — covers core patterns (sequential, hierarchical,
  parallel, event-driven), anti-patterns, and the five-layer model (Cognition → Context → Interaction →
  Runtime → Governance) for separating concerns in production-grade agentic systems.
  NOT for reviewing existing agentic code (use review-methodology) or framework selection (use the frameworks skill).
portability: portable
---

# Agentic Patterns

Reference guide for proven agentic architecture patterns and common anti-patterns to avoid.

## Core Patterns

### Sequential Pattern
Agents execute in fixed order. Each agent's output feeds the next.

**Use when:** Linear workflow, clear dependencies, predictable stages.

**Example:** Research → Analyze → Draft → Review

**Tradeoffs:** Simple coordination, but bottlenecks if any agent is slow.

### Hierarchical Pattern
Parent agent delegates to specialized child agents. Parent aggregates results.

**Use when:** Complex tasks decomposable into subtasks, need centralized coordination.

**Example:** Project manager agent delegates to designer, developer, QA agents.

**Tradeoffs:** Clear accountability, scales well, but single point of failure at parent.

### Collaborative Pattern
Peer agents work together on shared problem. No fixed hierarchy.

**Use when:** Problem benefits from diverse perspectives, no clear lead agent.

**Example:** Multiple specialized reviewers collaborating on code review.

**Tradeoffs:** Rich outputs, but requires conflict resolution and consensus mechanisms.

### Autonomous Pattern
Agents operate independently with minimal coordination.

**Use when:** Tasks are fully independent, parallel execution needed.

**Example:** Multiple monitoring agents checking different services.

**Tradeoffs:** Maximum parallelism, but no shared learning or coordination.

### Human-in-the-Loop Pattern
Human approval gates at critical decision points.

**Use when:** High-stakes decisions, regulatory requirements, learning from human feedback.

**Example:** Agent drafts report, human approves before sending.

**Tradeoffs:** Adds latency, but ensures safety and quality.

### ReAct Pattern
Reason → Act → Observe cycle. Agent reasons about next action, executes it, observes result, repeats.

**Use when:** Dynamic environments, need adaptive behavior based on feedback.

**Example:** Debugging agent tries fixes, observes test results, adapts approach.

**Tradeoffs:** Flexible and adaptive, but can be inefficient if reasoning is expensive.

### Plan-Execute Pattern
Agent creates full plan upfront, then executes all steps.

**Use when:** Environment is predictable, planning overhead is justified.

**Example:** Multi-step data pipeline with known transformations.

**Tradeoffs:** Efficient execution, but brittle if environment changes.

### Reflection Pattern
Agent reviews its own outputs and iteratively improves them.

**Use when:** Quality matters more than speed, self-improvement is valuable.

**Example:** Writer agent drafts, critiques, and refines output.

**Tradeoffs:** Higher quality outputs, but increased token usage and latency.

## Anti-Patterns Quick Reference

1. **God Agent:** Single agent doing everything. Split responsibilities.
2. **Tight Coupling:** Agents depend on internal implementation details. Use interfaces.
3. **Missing Guardrails:** No constraints on agent actions. Add validation and limits.
4. **Deep Nesting:** Agents calling agents calling agents. Flatten hierarchy.
5. **No Observability:** Can't see what agents are doing. Add logging and tracing.
6. **Sequential Bottleneck:** Everything waits for slowest agent. Add parallelism.
7. **Context Bloat:** Passing entire history to every agent. Compress and filter.
8. **Redundant Agents:** Multiple agents doing same thing. Consolidate.
9. **Hardcoded Prompts:** Prompts baked into code. Externalize and version.
10. **Missing Timeouts:** Agents can run forever. Add time and resource limits.

## Pattern Selection Decision Tree

```
Is task decomposable into subtasks?
├─ YES: Is there a clear lead/coordinator role?
│   ├─ YES: Use Hierarchical
│   └─ NO: Use Collaborative
└─ NO: Does task require adaptation based on results?
    ├─ YES: Can you plan all steps upfront?
    │   ├─ YES: Use Plan-Execute
    │   └─ NO: Use ReAct
    └─ NO: Do you have multiple independent tasks?
        ├─ YES: Use Autonomous
        └─ NO: Use Sequential
```

Add Human-in-the-Loop gates for any high-stakes decisions.
Add Reflection layer when quality is critical.

## Combining Patterns

Patterns are composable:
- **Hierarchical + ReAct:** Parent plans, children adapt execution
- **Sequential + Reflection:** Each stage includes self-review
- **Collaborative + Human-in-Loop:** Peer review with human arbitration
- **Autonomous + Hierarchical:** Independent teams with team leads

## Pattern Anti-Affinities

Avoid these combinations:
- **Plan-Execute + ReAct:** Contradictory - either plan upfront or adapt dynamically
- **Autonomous + Tight Coordination:** Defeats the purpose of autonomy
- **Deep Hierarchies + Reflection:** Exponential token cost

## Quick Start

1. Identify if task is decomposable (subtasks?) or atomic
2. Identify if execution is predictable (plan?) or dynamic (adapt?)
3. Identify if agents should coordinate (hierarchy/collaboration) or work independently
4. Check anti-patterns list against current design
5. See refs/pattern-catalog.md for detailed examples

## References

- `refs/pattern-catalog.md` - Detailed pattern descriptions with implementation examples
- `refs/anti-patterns-design.md` - Design anti-patterns (God Agent, Tight Coupling, Missing Guardrails, Deep Nesting, No Observability)
- `refs/anti-patterns-operational.md` - Operational anti-patterns (Sequential Bottleneck, Context Bloat, Redundant Agents, Hardcoded Prompts, Missing Timeouts)