Agent Loops & Planning

What is an AI Agent?

A standard LLM is a passive text generator: you send a prompt, it generates a response, and the execution stops.

An AI Agent is an autonomous goal directed system:

Give an agent a high level objective ("Research the latest news on Quantum Computing and write a 500 word summary report"), and the agent will plan, execute tools, observe results, self correct, and iterate autonomously until the goal is achieved.

  HIGH-LEVEL GOAL: "Research Quantum Computing News & Write Report"
        │
        ▼
  ┌─────────────────────────────────────────────────────────────┐
  │ AGENT REASONING LOOP (Thought -> Action -> Observation)      │
  │ - Thought 1: "I need to search web for recent news."        │
  │ - Action 1:  web_search("quantum computing 2026")          │
  │ - Observe 1: Received 5 article links.                      │
  │ - Thought 2: "Link 2 looks promising. Let me read it."     │
  │ - Action 2:  read_url("https://...")                        │
  │ - Observe 2: Received full article text.                    │
  │ - Thought 3: "I have sufficient info. Writing report."     │
  └──────────────────────────┬──────────────────────────────────┘
                             │
                             ▼
  FINAL DELIVERABLE REPORT COMPLETED!

The ReAct Framework (Reason + Act - Yao et al., 2022)

The ReAct Pattern is the foundational architecture for AI agents:

┌──────────────────────────┬──────────────────────────┬──────────────────────────┐
│ 1. THOUGHT               │ 2. ACTION                │ 3. OBSERVATION           │
├──────────────────────────┼──────────────────────────┼──────────────────────────┤
│ Model writes an explicit │ Model calls a tool       │ Environment returns API  │
│ reasoning thought to plan│ (web search, SQL, code   │ payload or error message │
│ its next step.           │ execution, calculator).  │ back into context.       │
└──────────────────────────┴──────────────────────────┴──────────────────────────┘

By interleaving Thought reasoning with Action execution, the agent can adapt its plan dynamically when a tool returns unexpected errors.

The 4 Pillars of Agent Architecture

┌──────────────────────────┬──────────────────────────┬──────────────────────────┬──────────────────────────┐
│ 1. BRAIN (LLM)           │ 2. PLANNING              │ 3. MEMORY                │ 4. TOOLS                 │
├──────────────────────────┼──────────────────────────┼──────────────────────────┼──────────────────────────┤
│ Central LLM reasoning    │ Task decomposition (ToT, │ Short-term (context),    │ External APIs, Python    │
│ & decision engine.       │ Sub-goal planning).      │ Long-term (Vector DB).   │ REPL, Web Browsing.      │
└──────────────────────────┴──────────────────────────┴──────────────────────────┘

Common Agent Failure Modes & Production Defenses

1. Infinite Execution Loops: An agent calls a broken tool API, receives an error, and retries the exact same broken tool call 100 times.
   • Defense: Set strict max_iterations = 10 limits and implement explicit retry counters.
2. Context Window Exhaustion: Multi-step agent loops accumulate thousands of observation tokens, exceeding context limits.
   • Defense: Use Memory Summarization or clear intermediate observation details once a sub-goal is completed.
3. Cascading Error Drift: A small mistake in Step 2 causes Step 3, 4, and 5 to go completely off track.
   • Defense: Add a Reflection Step where the agent periodically evaluates its own progress against the original objective.

Say this out loud

AI Agents are autonomous systems driven by LLMs operating in iterative Thought Action Observation loops. The ReAct framework interleaves reasoning thoughts with tool actions, allowing agents to observe environmental feedback, self correct errors, and execute multi step workflows autonomously. Production agents require iteration caps and memory management to prevent infinite loops.

Followups to expect

1. What is Multi-Agent Collaboration (AutoGen / CrewAI)? Orchestrating multiple specialized agents (e.g. Researcher Agent, Writer Agent, Reviewer Agent) that pass tasks and feedback messages to each other to complete complex projects.
2. What is Reflection / Self-Correction in Agents? Prompting an agent after an action to evaluate whether its output met quality standards before presenting the result to the user.