Pattern Selection Framework: Choosing the Right Patterns¶

Overview¶

Understanding 12 patterns is one thing. Knowing which to use for YOUR system is another.

This framework walks through the decision process used by production teams to select patterns for their agentic systems.

The 3-Step Selection Process¶

Step 1: Understand Your Problem
  ↓
Step 2: Identify Core Constraints
  ↓
Step 3: Select Pattern Combination
  ↓
Step 4: Validate & Iterate

Step 1: Understand Your Problem¶

Classify Your Task¶

Task Type	Example	Characteristics
Question Answering	"What's in these documents?"	Single shot, grounded, fast
Multi-Step Workflow	"Research and write report"	Sequential, complex, iterative
Real-Time Interaction	"Answer customer questions"	Fast, responsive, specialized
Creative Generation	"Write marketing copy"	Quality-focused, iterative
Autonomous Agent	"Manage calendar and email"	Continuous, self-directed
Team Coordination	"Build analysis team"	Multi-agent, specialist

Define Your Goal¶

Be specific: - ✅ "Summarize customer support tickets with 95% accuracy" - ❌ "Use AI to improve customer support"

State success criteria: - Accuracy target? - Latency requirement? - Cost budget? - Quality bar? - User satisfaction?

Step 2: Identify Core Constraints¶

Time Constraint¶

< 100ms:  RAG only (maybe + simple tools)

100ms-1s: RAG + Tool Use + Error Recovery

1-10s:    Simple Agentic Loop + Tools

10s+:     Full orchestration possible

Decision: How fast must this be?

Quality Constraint¶

Good enough (80%):    Tool Use + Error Recovery

High quality (90%):   + Reflection + Planning

Very high (95%+):     + CoT + Memory + Routing

Decision: What's your quality target?

Cost Constraint¶

Budget per call:

$0.001-0.01:   Simple RAG or basic loop
$0.01-0.1:     Multi-step with reflection
$0.1+:         Full orchestration OK

Decision: What's your cost budget?

Complexity Constraint¶

Team capacity:

1-2 engineers:    Keep it simple (2-3 patterns)

5-10 engineers:   Moderate (5-7 patterns)

20+ engineers:    Full stack (10-12 patterns)

Decision: How much can your team handle?

Safety/Compliance Constraint¶

Low risk (personal use):
  No HITL required
  Simple error handling

Medium risk (business):
  HITL on medium-impact decisions
  Audit logs required
  User override possible

High risk (financial/healthcare):
  HITL on all material decisions
  Full audit trail
  Compliance monitoring
  Regular testing

Decision: How much safety/oversight needed?

Step 3: Select Pattern Combination¶

The Decision Tree¶

START
 │
  - Is this a Q&A task?
  - YES → Start with: RAG
  - NO  → Continue
 │
  - Does it need to take action?
  - YES → Add: Tool Use + Error Recovery
  - NO  → Continue (Question answering)
 │
  - Is it multi-step?
  - YES → Add: Planning
  - NO  → Continue
 │
  - Need exploration/iteration?
  - YES → Add: Agentic Loop
  - NO  → Continue
 │
  - Quality paramount?
  - YES → Add: Reflection + CoT
  - NO  → Continue
 │
  - Multiple input types?
  - YES → Add: Routing
  - NO  → Continue
 │
  - Need to maintain context?
  - YES → Add: Memory
  - NO  → Continue
 │
  - Multiple agents?
  - YES → Add: Multi-Agent Coordination
  - NO  → Continue
 │
  - High-impact decisions?
    YES → Add: HITL
    NO  → Continue

RESULT: Your pattern combination

Common Selections¶

Selection 1: Simple RAG Bot¶

✓ RAG
✓ Tool Use (search, fetch)
✓ Error Recovery

Cost: $0.001-0.01 per call
Latency: <1 second
Quality: 85%
Complexity: Low
Production: 15% of systems

Example: FAQ bot, documentation search

Selection 2: Agentic Research Agent¶

✓ Agentic Loop
✓ Tool Use (search, fetch, analyze)
✓ Planning
✓ Memory
✓ Error Recovery
✓ HITL (optional)

Cost: $0.01-0.1 per call
Latency: 5-30 seconds
Quality: 95%
Complexity: Medium
Production: 40% of systems

Example: Research assistant, data analyst

Selection 3: Customer Support Team¶

✓ Routing (classify issue)
✓ Tool Use (APIs, databases)
✓ Reflection (improve response)
✓ Memory (customer history)
✓ Error Recovery
✓ HITL (escalation)

Cost: $0.01-0.05 per interaction
Latency: 1-5 seconds
Quality: 90-95%
Complexity: Medium-High
Production: 25% of systems

Example: Enterprise customer support

Selection 4: Full Enterprise System¶

✓ Multi-Agent Coordination
✓ Agentic Loops (specialist agents)
✓ Planning & Decomposition
✓ Tool Use (extensive APIs)
✓ Memory (persistent)
✓ Routing (task distribution)
✓ Reflection (quality control)
✓ HITL (approval workflows)
✓ Error Recovery
✓ RAG (knowledge access)

Cost: $0.05-0.5+ per interaction
Latency: 10s-5min (async)
Quality: 98%+
Complexity: High
Production: <5% of systems

Example: Full enterprise research platform

Framework: 3x3 Matrix¶

Quick lookup by Complexity vs Speed vs Quality

                LATENCY (Time)
              Low      Medium      High
            (<1s)    (1-10s)     (>10s)
- ┌─────────┬──────────┬──────────┐
        - High    │  RAG    │  RAG +   │ Multi-   │
        - Quality │ (Simple)│  Tools   │  Agent   │
        - (95%+)  │         │  + Refl  │ (Full)   │
  - ┼──────────┼──────────┤
        - Medium  │  RAG +  │  Loop +  │  Loop +  │
        - Quality │  Tools  │  Plan +  │  Memory  │
        - (80-90%)│         │  Tools   │ + Multi  │
  - ┼──────────┼──────────┤
        - Good    │  Simple │  Tool    │ Planning │
        - Quality │  Tool   │  Use +   │ + Loop   │
        - (70-80%)│  Use    │  Error   │          │
  - ┴──────────┴──────────┘

Detailed Selection Guide¶

"I need to answer questions from documents"¶

→ Start: RAG
→ Add if needed: Tool Use, Error Recovery
→ If quality issues: + Reflection
→ If customer-facing: + HITL

Typical: RAG + Error Recovery

"I need an autonomous research agent"¶

→ Start: Agentic Loop
→ Add: Tool Use (search, fetch, analyze)
→ Add: Planning (break down research)
→ Add: Memory (remember findings)
→ Add: Error Recovery
→ If multi-phase: + Reflection

Typical: Agentic Loop + Tool Use + Planning + Memory

"I need customer support"¶

→ Start: Routing (classify issue type)
→ Add: Tool Use (customer DB, APIs)
→ Add: RAG (knowledge base)
→ Add: Reflection (improve responses)
→ Add: Memory (customer history)
→ Add: Error Recovery
→ Add: HITL (escalation)

Typical: Routing + RAG + Tool Use + HITL

"I need a team of agents"¶

→ Start: Multi-Agent Coordination
→ Add: Routing (task distribution)
→ Each agent: Agentic Loop + Tool Use
→ Add: Planning (task decomposition)
→ Add: Memory (shared context)
→ Add: HITL (oversight)

Typical: Multi-Agent + Routing + Planning + HITL

"I need creative generation"¶

→ Start: Reflection (quality)
→ Add: CoT (complex reasoning)
→ Add: Memory (maintain voice/style)
→ Add: Error Recovery
→ If iterative: + Agentic Loop

Typical: Reflection + CoT + Memory

"I need very fast responses"¶

→ Use: RAG only (no looping)
→ Add: Tool Use only if necessary
→ Avoid: Agentic Loop, Reflection, CoT

Typical: RAG + minimal tools

"I need maximum quality"¶

→ Use: Reflection, CoT, Planning
→ Add: Agentic Loop (iteration)
→ Add: Memory (learning)
→ Cost higher, latency higher
→ Speed acceptable

Typical: Agentic Loop + Reflection + CoT + Memory

Pattern Swap Table: "I'm having this problem..."¶

Problem: Output Quality Too Low¶

Current: RAG + Tool Use
Add:     Reflection
         CoT
         Agentic Loop (iterate)

Problem: Hallucinating/Inaccurate¶

Current: Agentic Loop
Add:     RAG (ground in docs)
         Memory (cross-check facts)
         Error Recovery (fallback)

Problem: Too Slow¶

Current: Agentic Loop + Reflection
Remove:  Reflection
Replace: RAG
Simplify: Single pass instead of loop

Problem: Too Expensive¶

Current: Full orchestration
Simplify to:  Essential patterns only
Remove:  Reflection, HITL if optional
Cache:   RAG results when possible

Problem: Can't Handle Complexity¶

Current: Single agent
Add:     Multi-Agent Coordination
         Routing (task distribution)
         Parallelization (parallel work)

Problem: Users Don't Trust It¶

Current: Autonomous
Add:     HITL (override capability)
         Audit trail (show reasoning)
         Reflection (self-critique)

Problem: Errors Cascade¶

Current: Basic error handling
Add:     Error Recovery pattern
         Fallback paths
         Bounded execution
         Graceful degradation

Validation Checklist¶

Before committing to pattern selection, verify:

✓ Does this solve the core problem?
✓ Within time budget?
✓ Within cost budget?
✓ Quality meets target?
✓ Team can build/maintain it?
✓ Users will trust it?
✓ Can we recover if it fails?
✓ Can we improve over time?
✓ Will it scale?

If any "No" → Adjust pattern selection

Implementation Order¶

Once you've selected patterns, implement in this order:

Phase 1: Core (Week 1)¶

Tool Use + Error Recovery
Get basic execution working

Phase 2: Intelligence (Week 2-3)¶

Add Planning or RAG
Improve task handling

Phase 3: Quality (Week 4-5)¶

Add Reflection/CoT
Increase output quality

Phase 4: Sophistication (Week 6+)¶

Add Memory
Add HITL
Add monitoring

Phase 5: Scaling (Month 2+)¶

Add Multi-Agent if needed
Add Routing if needed
Production optimization

Case Studies: Pattern Selection in Action¶

Case Study 1: Startup Support Bot¶

Constraints:
- Speed: <1 second
- Cost: <$0.01/call
- Quality: 80% OK
- Team: 2 engineers

Selection:
✓ RAG (documents)
✓ Tool Use (simple APIs)
✓ Error Recovery

Result: Launched in 2 weeks
Cost: $0.005/call
Quality: 82%
User satisfaction: 4.2/5

Case Study 2: Enterprise Research Platform¶

Constraints:
- Speed: <30 seconds acceptable
- Cost: $0.1/call OK
- Quality: 95%+ required
- Team: 8 engineers

Selection:
✓ Agentic Loop (exploration)
✓ Planning (multi-step)
✓ Tool Use (multiple sources)
✓ Memory (findings)
✓ Reflection (quality)
✓ HITL (review before publish)
✓ Error Recovery

Result: Launched in 8 weeks
Cost: $0.08/call
Quality: 96%
User satisfaction: 4.8/5

Case Study 3: Customer Support System¶

Constraints:
- Speed: 2-5 seconds
- Cost: $0.02/call
- Quality: 90%+
- Team: 12 engineers
- Safety: Medium (business use)

Selection:
✓ Routing (classify issues)
✓ RAG (knowledge base)
✓ Tool Use (APIs)
✓ Memory (customer history)
✓ Reflection (response quality)
✓ HITL (escalation)
✓ Error Recovery

Result: Launched in 12 weeks
Cost: $0.018/call
Quality: 92%
Escalation rate: 12%
User satisfaction: 4.5/5
CSAT improvement: +35%

Key Decisions Summary¶

The 5 Critical Questions¶

Speed: How fast must this be?
<1s → RAG-based
1-10s → Agentic Loop
10s+ → Full orchestration OK
Quality: How accurate must this be?
80% → Simple patterns
90% → Add Reflection/Planning
95%+ → Full stack needed
Actions: Must it interact with systems?
No → RAG-focused
Yes → Add Tool Use + Error Recovery
Complexity: Is the task multi-step/exploration?
No → Single pass (RAG/Tool)
Yes → Agentic Loop
Safety: Is oversight required?
No → Autonomous OK
Yes → Add HITL

Quick Reference Card¶

PATTERN SELECTION QUICK GUIDE

Task Type               Minimum Patterns
- ──────────────────────
Q&A from documents     RAG + Error Recovery
Simple action          Tool Use + Error Recovery
Multi-step task        Planning + Tool Use
Autonomous agent       Agentic Loop + Tools
Quality-critical       + Reflection + CoT
Customer-facing        + HITL
Learning over time     + Memory
Large projects         + Multi-Agent

Remember:
START SIMPLE, ADD AS NEEDED

Iteration & Feedback Loop¶

Your pattern selection isn't final:

1. Select patterns
   ↓
2. Build & test
   ↓
3. Measure results
   ↓
4. Collect feedback
   ↓
5. Adjust patterns
   ↓
6. Repeat

What to measure: - Quality/accuracy - Latency - Cost - User satisfaction - Error rates - Adoption

When to change patterns: - Quality below target → Add Reflection/CoT - Too slow → Simplify, use RAG - Too expensive → Remove Reflection, cache results - Low adoption → Add HITL, Reflection - Errors increasing → Add Error Recovery - Complexity too high → Split into Multi-Agent

Next: Implement Your Patterns¶

Choose your patterns using this framework
Read the detailed pattern guides
Implement Phase 1 (Core)
Test and measure
Add phases iteratively
Monitor and adjust

Last Updated: August 9, 2026