AgentAcademy
Start Learning
Module 2
15 min read

How AI Agents Work

Dive deep into the architecture of AI agents: the agent loop, reasoning patterns, and memory systems.

The Agent Loop

At the heart of every AI agent is a simple but powerful cycle called the agent loop. This loop runs continuously until the task is complete:

1

Observe

Gather information about the current state - read files, check outputs, understand context

2

Think

Reason about what to do next - plan steps, consider options, make decisions

3

Act

Execute an action using a tool - write a file, run a command, call an API

4

Repeat

Go back to step 1 with new information until the goal is achieved

This loop is deceptively simple, but it enables incredibly complex behavior. Each iteration builds on the previous ones, allowing the agent to tackle multi-step problems.

The ReAct Pattern

One of the most influential patterns in agentic AI is ReAct (Reasoning + Acting). Instead of just acting, the agent explicitly reasons about each step:

User: Create a function to calculate fibonacci numbers

Agent Thought: I need to create a fibonacci function. First, let me
check if there's an existing math utilities file in the codebase.

Agent Action: Search for "math" or "utils" files

Agent Observation: Found src/utils/math.ts

Agent Thought: Good, there's already a math utilities file. I should
add the fibonacci function there to keep the code organized.

Agent Action: Read src/utils/math.ts

Agent Observation: [File contents shown]

Agent Thought: The file exists with other math functions. I'll add
the fibonacci function following the same style.

Agent Action: Edit src/utils/math.ts to add fibonacci function

Agent Observation: File updated successfully

Agent Thought: The function is added. I should verify it works.
...

This explicit reasoning serves several purposes:

  • Transparency - You can see why the agent made each decision
  • Accuracy - Thinking step-by-step reduces errors
  • Debuggability - When something goes wrong, you can trace the logic

Memory Systems

Agents need memory to work effectively. There are several types:

Working Memory

The current conversation context. What's been said, what files have been read, what actions have been taken in this session.

Long-Term Memory

Persistent knowledge stored between sessions. User preferences, project patterns, learned information.

Procedural Memory

Knowledge of how to do things - the tools available, how to use them, when each is appropriate.

Episodic Memory

Memories of specific events and outcomes. What worked before, what failed, lessons learned.

The Role of the LLM

At the core of modern agents is a Large Language Model (LLM) like Claude. The LLM provides:

  • Natural language understanding - Interpreting user requests
  • Reasoning - Planning and decision-making
  • Code generation - Writing actual code when needed
  • Tool selection - Choosing which tool to use when
  • Output formatting - Structuring responses appropriately

The LLM as "Brain"

Think of the LLM as the agent's brain. It doesn't directly interact with the world - it thinks, plans, and decides. The tools are like the agent's hands - they carry out the brain's decisions in the real world. The combination of a powerful brain and capable hands is what makes agentic AI so effective.

Orchestration Layer

Between the LLM and the tools sits an orchestration layer. This is the software that manages the agent loop:

// Simplified orchestration pseudocode
while (!taskComplete) {
  // Get LLM's decision
  const response = await llm.chat(messages);

  // Check if LLM wants to use a tool
  if (response.toolCalls) {
    for (const call of response.toolCalls) {
      // Execute the tool
      const result = await tools[call.name](call.arguments);

      // Add result to conversation
      messages.push({ role: 'tool', content: result });
    }
  }

  // Check if task is complete
  if (response.finished) {
    taskComplete = true;
  }
}

This orchestration handles:

  • Parsing tool calls from LLM responses
  • Executing tools safely and securely
  • Managing conversation history
  • Enforcing rate limits and permissions
  • Handling errors and retries

Planning Strategies

Sophisticated agents use various planning strategies:

Task Decomposition

Breaking a complex task into smaller, manageable subtasks. "Build a website" becomes "1. Set up project, 2. Create layout, 3. Add pages, 4. Style components..."

Hierarchical Planning

Creating plans at multiple levels of abstraction. High-level strategy guides mid-level tactics, which guide low-level actions.

Adaptive Re-planning

Adjusting the plan when things don't go as expected. If a file doesn't exist, create it. If an approach fails, try another.

Key Takeaways

  • The agent loop (Observe → Think → Act → Repeat) is the foundation of agentic behavior
  • ReAct combines reasoning with action for more reliable results
  • Memory systems allow agents to build on previous work and learn from experience
  • The LLM serves as the "brain" while tools serve as the "hands"
  • An orchestration layer manages the interaction between LLM and tools
Module 1: IntroductionModule 3: Tool Use