Agent Architecture: Goals, Tools, and Reasoning

In Lesson 1, you learned what agents are. Now let’s understand how they work inside — the architecture that makes autonomous behavior possible.

The Reasoning Loop

Every AI agent runs on a loop. It’s deceptively simple:

1. Observe — What’s the current state? What do I know? What have I done so far?
2. Think — Given my goal and current state, what should I do next?
3. Act — Execute the next step using available tools
4. Evaluate — Did that work? Am I closer to my goal?
5. Repeat — If the goal isn’t met, go back to step 1

This loop runs until the agent either achieves its goal, hits a limit (max steps, time, budget), or gets stuck and asks for help.

The magic is in step 2 — the “think” step. Modern language models are good enough to plan, reason about complex situations, and adapt when things don’t go as expected.

Demonstrate the reasoning loop for this agent task:

GOAL: Find the three cheapest flights from New York to London for March 15-22, 2026

Walk through the loop step by step:
1. What does the agent observe initially?
2. What does it think/plan?
3. What action does it take first?
4. What does it observe after that action?
5. How does it evaluate and decide the next step?
Continue until the goal is achieved (use hypothetical results).

✅ Quick Check: What are the five steps of the agent reasoning loop?

Observe (assess current state), Think (plan next action), Act (execute using tools), Evaluate (check progress toward goal), Repeat (loop until done). This cycle is the engine that drives all autonomous agent behavior.

Goal Design

A poorly defined goal produces a poorly performing agent. Good goals follow the SMART-A framework for agents:

Specific — “Research the top 5 CRM platforms for small businesses” beats “research CRMs.”

Measurable — How does the agent know when it’s done? “Produce a comparison table with pricing, features, and ratings for 5 platforms.”

Achievable — The agent must have the tools to accomplish the goal. Don’t ask an agent without web access to research current prices.

Relevant — The goal should match the agent’s capabilities. Don’t ask a research agent to execute financial transactions.

Time/Token-bounded — Set limits on how long or how many steps the agent can take. Without bounds, agents can loop indefinitely.

I want to create an agent goal for this task: [describe your task]

Help me write the goal following the SMART-A framework:
1. Specific: What exactly should the agent produce?
2. Measurable: How do we verify the output is complete and correct?
3. Achievable: What tools does the agent need?
4. Relevant: Is this within an agent's capabilities?
5. Time-bounded: What are reasonable step/time limits?

Write the final goal statement I'd give to an agent.

Tool Architecture

Tools are what make agents more than chatbots. A tool is any capability the agent can invoke:

The agent decides which tools to use based on the current step. Researching a competitor? Use web search. Analyzing the data? Use code execution. Writing the report? Use file writing.

Designing your tool set:

I'm building an agent for [task]. Help me design its toolkit:

1. What tools does the agent need to accomplish this goal?
2. What inputs does each tool require?
3. What outputs does each tool produce?
4. Are there any tools that are nice-to-have vs. essential?
5. What happens if a tool fails or returns unexpected results?

Memory Systems

Agents need memory to work effectively. Three types matter:

Working memory — What the agent is currently thinking about. The current step, recent tool results, and immediate context. This is typically the conversation/context window.

Episodic memory — What happened during this task. Steps taken, results received, errors encountered. This prevents the agent from repeating failed approaches.

Persistent memory — Knowledge that survives across sessions. User preferences, previous research results, learned patterns. Useful for agents that run repeatedly.

Most current agent frameworks handle working memory automatically (it’s the model’s context window). Episodic memory requires deliberate design — logging actions and results. Persistent memory typically uses databases or files.

Agent Patterns

Different tasks call for different agent architectures:

Sequential agent — Steps execute in order: research → analyze → write → review. Best for tasks with a clear linear flow.

Branching agent — The agent decides between paths based on what it finds. “If the data is structured, analyze directly. If unstructured, extract and clean first.” Best for tasks with conditional logic.

Iterative agent — The agent repeats a process until quality is sufficient. “Write a draft, evaluate it, improve weak sections, re-evaluate.” Best for creative or quality-sensitive tasks.

Parallel agent — Multiple sub-tasks run simultaneously. “Research Company A, B, and C at the same time, then combine findings.” Best for tasks where steps don’t depend on each other.

For this task, which agent pattern fits best? Explain why:

TASK: [describe your task]

Compare the four patterns (sequential, branching, iterative, parallel) and recommend the best architecture. Include a diagram showing how the steps would flow.

Exercise: Design an Agent Architecture

Pick a real task you’d want an agent to handle and design the complete architecture:

1. Write the goal using SMART-A framework
2. List the tools the agent needs
3. Map out the reasoning loop for this specific task (what does each observe-think-act-evaluate cycle look like?)
4. Choose the agent pattern (sequential, branching, iterative, or parallel)
5. Define what memory the agent needs

Use AI to help refine each component. Save this architecture — you’ll build it into a working agent in the next lesson.

Key Takeaways

• The reasoning loop (observe, think, act, evaluate, repeat) is the engine of every AI agent
• Well-defined goals using the SMART-A framework produce dramatically better agent performance
• Tools give agents capabilities beyond text generation: search, code, files, APIs, databases, and browser control
• Three memory types matter: working memory (current context), episodic (task history), and persistent (cross-session knowledge)
• Four agent patterns cover most use cases: sequential, branching, iterative, and parallel
• Architecture design before building prevents wasted effort and unreliable results

Up Next: In the next lesson, you’ll take this architecture and build your first working AI agent — from goal to execution to result.