Mastering AI Agents: The Planner-Executor-Memory Pattern

1. Concept Introduction

At the heart of many sophisticated AI agents lies a simple yet powerful pattern: Planner-Executor-Memory. This architecture provides a structured way for an agent to reason, act, and learn.

For the Beginner: Imagine you’re building a piece of IKEA furniture. You first look at the instructions and make a high-level plan: “First, I’ll assemble the frame, then I’ll attach the doors, and finally, I’ll insert the shelves.” This is the Planner phase. Next, you pick up the screwdriver and start putting the pieces together, following your plan step-by-step. This is the Executor phase. As you work, you might jot down notes (“allen key #5 is the important one”) or simply remember which parts you’ve already used. This is your Memory.

For the Practitioner: The Planner-Executor-Memory pattern is a cognitive architecture for autonomous agents.

2. Historical & Theoretical Context

The idea of separating planning from execution is a cornerstone of classical Artificial Intelligence. Early AI systems like STRIPS (Stanford Research Institute Problem Solver), developed in the late 1960s, were based on this principle. STRIPS used a formal language to describe states, goals, and actions, and a planner to find a sequence of actions to achieve a goal.

The Planner-Executor model connects directly to the principles of means-ends analysis, a problem-solving technique where you work backward from the goal to identify the “means” (actions) to achieve it. In modern agents, LLMs have supercharged the planning component, allowing for more flexible and common-sense reasoning than was possible with classical planners.

3. Algorithms & Math

The core loop is straightforward and can be expressed in pseudocode:

function AgentLoop(goal):
  memory = InitializeMemory()
  plan = Planner(goal, memory)

  while not plan.is_complete():
    step = plan.get_next_step()
    result = Executor(step)
    
    memory.update(step, result)
    
    if needs_replan(result):
      plan = Planner(goal, memory) // Re-plan based on new info

  return memory.get_final_result()

The needs_replan condition is critical. An agent that blindly follows a plan is brittle. The ability to re-plan based on unexpected outcomes or errors is what makes this architecture robust.

4. Design Patterns & Architectures

The Planner-Executor-Memory pattern is a high-level architectural pattern that can be implemented in various ways:

This pattern is the foundation of many agent frameworks. For example, in LangGraph, the planner might be one node in a graph, and the executor might be another, with the memory passed along the edges as the state object.

5. Practical Application

Here’s a simplified Python example of the pattern.

import json

def simple_planner(goal):
  """A mock planner that returns a fixed plan."""
  print(f"Planner: Received goal - '{goal}'")
  return [
    {"tool": "search", "query": "latest AI agent research"},
    {"tool": "write_file", "filename": "summary.txt", "content": "placeholder"}
  ]

def simple_executor(step):
  """A mock executor that simulates tool calls."""
  print(f"Executor: Executing step - {step['tool']}")
  if step["tool"] == "search":
    # In a real agent, this would call a search API
    return "Found a paper on 'Planner-Executor-Memory Pattern'."
  elif step["tool"] == "write_file":
    # In a real agent, this would write to the filesystem
    return f"Successfully wrote to {step['filename']}"

def agent(goal):
  """The main agent loop."""
  memory = {"goal": goal, "steps_taken": [], "observations": []}
  plan = simple_planner(goal)
  
  for step in plan:
    result = simple_executor(step)
    memory["steps_taken"].append(step)
    memory["observations"].append(result)
    
    # A simple re-planning trigger
    if "error" in result.lower():
      print("Re-planning might be needed here.")
      # new_plan = simple_planner(goal) # Re-plan
      
  print("
--- Agent Finished ---")
  print(json.dumps(memory, indent=2))

# Run the agent
agent("Summarize the latest research on AI agents.")

In a framework like CrewAI, you define agents with goals and backstories (which informs the planner) and assign them tasks. The framework then orchestrates the execution of these tasks, managing the memory of what has been done.

6. Comparisons & Tradeoffs

Planner-Executor vs. Reactive Agents:

The choice depends on the problem. A self-driving car needs a reactive component to brake suddenly, but a research agent needs a planner to break down a complex query.

7. Latest Developments & Research

Recent research focuses on making the Planner-Executor loop more robust and efficient:

8. Cross-Disciplinary Insight

This pattern has strong parallels with Daniel Kahneman’s “Thinking, Fast and Slow” in cognitive psychology.

A well-functioning agent, like a well-functioning human, needs both: the ability to plan deliberately and the ability to execute efficiently.

9. Daily Challenge / Thought Exercise

Your 30-Minute Challenge:

Modify the Python code example above to include a simple form of re-planning.

  1. Add a step to the plan that is designed to fail (e.g., {"tool": "read_file", "filename": "non_existent_file.txt"}).
  2. In the simple_executor, detect this “failure” and return an error message.
  3. In the main agent loop, if an error is detected, call the simple_planner again to generate a new plan. For simplicity, the new plan can be a hard-coded “recovery” plan (e.g., [{"tool": "search", "query": "how to handle file not found errors"}]).

This will give you a hands-on feel for how an agent can adapt when its initial plan goes wrong.

10. References & Further Reading

../