Andrew Ng's 4 Core Patterns

Overview

Andrew Ng distilled agentic system design into 4 fundamental patterns in 2024-2025. These are the foundation all other patterns build upon.

---

Pattern 1: Reflection

What It Does

Agent generates output, then critiques and improves its own work before returning to user.

The Loop

Generate → Critique → Improve → Return

Benefits

• Higher quality outputs
• Catches obvious errors
• Reflects values back to agent

When to Use

• Quality is paramount (writing, analysis)
• LLM can self-critique effectively
• Extra inference cost is acceptable

Example: Essay Writing Agent

class ReflectionAgent:
    def run(self, prompt: str) -> str:
        # Generate
        draft = self.llm.generate(prompt)

        # Critique
        critique = self.llm.generate(f"""
            Critique this essay:
            {draft}

            Focus on: clarity, accuracy, completeness
        """)

        # Improve
        final = self.llm.generate(f"""
            Based on this feedback:
            {critique}

            Revise the essay:
            {draft}
        """)

        return final

Cost/Benefit

• Cost: 3x inference cost (generate, critique, improve)
• Benefit: ~30% quality improvement typical

---

Pattern 2: Tool Use

What It Does

Agent can call functions/APIs to gather information and take action.

The Loop

Reason → Choose Tool → Call Tool → Integrate Result → Repeat

Key Insight

This is what makes agents agents. Without tools, they're just chatbots.

Categories of Tools

• Information: Search, database query, retrieval
• Action: API calls, file writes, system commands
• Computation: Math, data analysis, code execution

Example: Research Agent

class ToolUsingAgent:
    def __init__(self, tools: Dict):
        self.tools = tools  # {name: function}

    def run(self, goal: str) -> str:
        while not self.done():
            # Decide which tool to use
            tool_choice = self.llm.choose_tool(
                goal=goal,
                available_tools=list(self.tools.keys())
            )

            # Call the tool
            result = self.tools[tool_choice.name](**tool_choice.args)

            # Integrate result
            self.update_context(result)

            # Check if done
            if self.goal_achieved():
                return self.format_result()

Real-World Impact

Enable agents to interact with actual systems: - Look up data in databases - Call APIs to execute transactions - Write files and documents - Send messages and notifications

---

Pattern 3: Planning

What It Does

Agent breaks complex goal into smaller sub-goals before executing.

The Loop

Goal → Decompose → Plan Steps → Execute Plan → Reflect

Why It Matters

Complex tasks fail without planning. Planning enables: - Clarity (understand scope) - Efficiency (avoid wasted steps) - Debuggability (can see step-by-step)

Example: Research Plan Agent

class PlanningAgent:
    def run(self, goal: str) -> str:
        # Step 1: Create plan
        plan = self.llm.generate(f"""
            Goal: {goal}

            Create a step-by-step plan. Each step should be:
            - Specific (what exactly to do)
            - Achievable (possible with available tools)
            - Ordered (early steps enable later ones)

            Format as numbered list.
        """)

        # Step 2: Execute plan
        results = []
        for step in plan.steps:
            result = self.execute_step(step)
            results.append(result)

        # Step 3: Compile results
        return self.llm.generate(f"""
            Original goal: {goal}
            Plan executed: {plan}
            Results: {results}

            Provide final comprehensive answer.
        """)

Cognitive Load

• Without planning: Agent gets lost, repeats work, inefficient
• With planning: Clear roadmap, better quality, sometimes slower

---

Pattern 4: Routing

What It Does

Directs incoming requests to specialist agents based on content.

The Loop

Incoming Request → Classify → Route → Specialist Agent → Respond

Benefits

• Specialists are more accurate
• Can use different models for different tasks
• Cost optimization (use right model for task)

Example: Customer Support Router

class RoutingAgent:
    def __init__(self):
        self.specialists = {
            "billing": BillingAgent(),
            "technical": TechnicalAgent(),
            "account": AccountAgent(),
            "general": GeneralAgent()
        }

    def route(self, customer_message: str) -> str:
        # Classify the issue
        category = self.llm.classify(customer_message)

        # Route to specialist
        specialist = self.specialists[category]

        # Get response
        response = specialist.handle(customer_message)

        return response

Production Usage

• Customer support (route to right team)
• API gateways (route to right service)
• Triage systems (route by priority/type)

---

How These Patterns Interact

- ┌─────────────────────────────────────────┐
    - User Request                    │
  - ┬──────────────────────────┘
               │
- ┌──────────▼──────────┐
    - Routing Pattern     │
    - (Which specialist?) │
  - ┬──────────┘
               │
- ┌──────────▼──────────┐
    - Planning Pattern    │
    - (What's the plan?)  │
  - ┬──────────┘
               │
- ┌──────────▼──────────┐
    - Tool Use Pattern    │
    - (Execute steps)     │
  - ┬──────────┘
               │
- ┌──────────▼──────────┐
    - Reflection Pattern  │
    - (Is it good?)       │
  - ┬──────────┘
               │
- ┌──────────▼──────────┐
    - Response       │
  - ┘

---

Pattern Selection Guide

Goal	Best Pattern	Why
Better quality	Reflection	Self-critique
Interact with systems	Tool Use	Need to take action
Complex tasks	Planning	Need roadmap
Multiple types of requests	Routing	Specialize response

---

Combining Patterns (Typical Production Agent)

class ProductionAgent:
    def run(self, request: str) -> str:
        # Step 1: Route to appropriate specialist
        category = self.route(request)
        specialist_config = self.specialists[category]

        # Step 2: Create plan for this request
        plan = self.plan(request, specialist_config)

        # Step 3: Execute plan using tools
        result = self.execute_with_tools(plan)

        # Step 4: Reflect and improve
        if self.should_reflect(result):
            result = self.reflect(result)

        return result

---

Key Metrics by Pattern

Pattern	Complexity	Quality Gain	Cost	Use Frequency
Reflection	Low	+30%	3x tokens	60%
Tool Use	Medium	+200%	Variable	80%
Planning	Medium	+50%	2x tokens	70%
Routing	Low	+20%	Minimal	50%

---

Common Mistakes

❌ Using reflection for every task (expensive)
❌ Forgetting to validate tool results
❌ Creating plans that are too detailed
❌ Routing incorrectly (misclassification)

---

Next: Read About Anthropic'S 5 Workflows

---

Last Updated: August 9, 2026