AI Agents

Introduction to AI Agents

The emergence of capable language models like GPT-4, Claude, and others has made building agents practical and powerful. An AI agent can be thought of as a loop: Observe → Think → Act → Observe. At each step, the agent uses reasoning frameworks (like ReAct), calls tools (APIs, databases, search engines), maintains memory of what it has learned, and coordinates with other agents to accomplish complex tasks.

What makes agents different from simple LLM applications is their agency — the ability to make decisions autonomously, call tools as needed, recover from errors, and interact with dynamic environments. A chatbot responds to one message at a time. An agent can decompose a task into subtasks, fetch information, integrate results, and iterate toward a goal.

What You'll Learn

Why AI Agents Matter

Agents represent the next frontier of AI capability. While large language models are powerful, they are fundamentally reactionary — they generate responses based on input. Agents are proactive and goal-directed. They persist over time, maintain state, take actions, and adapt based on results.

Agents vs. Traditional LLM Applications

Real-World Agent Applications

The Agent Capability Spectrum

Different applications require different levels of agent sophistication:

Core Concepts and Terminology

Before building agents, we need to establish a shared vocabulary. These concepts form the foundation of all agent design.

1. The Agent Loop: Observe → Think → Act → Observe

Every agent operates on a fundamental cycle:

This loop continues until the agent reaches a terminal state (goal achieved, max steps reached, or unrecoverable error).

2. Perception and Grounding

Perception is how agents understand the world. Unlike human perception (visual, auditory), AI agents perceive through:

• Language input: User queries, descriptions of the environment
• Structured data: Database queries, API responses, sensor readings
• Multimodal: Text + images, text + audio, text + video
• Implicit signals: Rewards, success/failure feedback, error messages

Grounding means connecting abstract concepts to concrete reality. An agent that only generates text is not grounded — it can hallucinate facts. An agent that calls APIs is grounded — it can verify facts against reality.

3. Goals and Task Decomposition

Agents are goal-directed. Given a goal, they must:

• Break it into subgoals or subtasks
• Reason about dependencies between tasks
• Execute subtasks in the right order
• Integrate results to achieve the overall goal

This is fundamentally different from single-prompt response. A user might say "Compare the 2026 revenue of Competitor A and Competitor B." The agent must decompose this into subtasks:

1. Find Competitor A's 2026 revenue (from their financial reports or APIs)
2. Find Competitor B's 2026 revenue (same source type)
3. Compare the two numbers and explain the difference
4. Draw conclusions about market position

4. Tool Use and Grounding Functions

Tools are how agents interact with the world. Common tools include:

5. Memory: The Agent's Long-Term Storage

While LLM context windows are limited (4K to 200K tokens), agents need to remember:

• Episodic memory: What happened in past interactions (conversation history)
• Semantic memory: Facts and knowledge learned (vector embeddings)
• Procedural memory: How to accomplish tasks (learned patterns, heuristics)
• State memory: Current progress toward goals

Agents use techniques like retrieval-augmented generation (RAG) to efficiently access relevant memories without overloading the context window.

6. Reasoning and Decision-Making

How agents decide what to do next is critical. Different reasoning frameworks include:

• Chain-of-Thought (CoT): Generate intermediate reasoning steps
• ReAct: Interleave reasoning (Thought) and acting (Action)
• Plan-and-Execute: Create a full plan first, then execute it
• Tree-of-Thought: Explore multiple reasoning paths and backtrack
• Hierarchical Planning: Abstract high-level goals into lower-level tactics

7. Error Handling and Recovery

Agents must be robust. When something goes wrong:

• Detection: Recognize that an action failed (error message, validation failure)
• Analysis: Understand why it failed
• Recovery: Try a different approach or ask for help
• Learning: Update mental model to avoid the same error next time

A naive agent that stops after the first failure is useless. A sophisticated agent adapts, retries with different parameters, or escalates to a human operator.

The Agent Loop in Detail

Let's zoom in on each phase of the agent loop and understand what happens.

Phase 1: Observation

The agent perceives its environment. This might be:

• A user query: "What is the market cap of Tesla?"
• Sensor data: A robot perceives an obstacle in its path
• API response: The agent receives feedback from a previous action
• Internal state: The agent checks its memory and current progress

The observation is encoded as context — usually text — that the agent processes.

Phase 2: Thinking

Given the observation, the agent thinks about what to do. The agent's "thinking" involves:

• Reasoning: Apply reasoning frameworks (ReAct, CoT) to understand the situation
• Planning: Generate one or more candidate next actions
• Evaluation: Estimate which action is most likely to make progress toward the goal
• Decision: Select the best action

This is where the LLM's reasoning comes in. Modern LLMs are remarkably good at this step when given proper prompting.

Phase 3: Action

The agent executes the selected action. This might be:

• Calling a tool: "Search the web for Tesla's market cap"
• Memory operation: "Store this fact for later retrieval"
• Communication: "Send this email"
• Environment modification: "Move the robot forward 1 meter"
• Special actions: "Ask the user for clarification" (escalation)

The action is typically structured (not free-form text). Modern agent frameworks use function calling — the LLM outputs a structured representation of what it wants to do.

Phase 4: Observation of Results

After the action, the agent observes the results:

• Success: The tool returned useful data
• Partial success: The tool returned something, but it's incomplete or noisy
• Failure: The tool returned an error

The agent feeds this result back into the reasoning loop. If the goal is achieved, it stops. Otherwise, it loops back to thinking.

Termination Conditions

Agents must have clear stopping conditions:

• Goal achieved: The agent has successfully completed the task
• Max iterations reached: The agent has taken N steps and should stop
• Unrecoverable error: The agent has encountered a fatal failure
• User interruption: The user has stopped the agent
• Escalation: The agent has decided the task requires human intervention

Animated Loop Diagram

Reasoning Frameworks: ReAct, Chain-of-Thought, and Beyond

Different situations require different reasoning approaches. Here are the major frameworks and when to use each.

1. Chain-of-Thought (CoT): Making Reasoning Visible

Chain-of-Thought is the simplest reasoning framework. The agent generates intermediate reasoning steps before arriving at a conclusion. Instead of jumping directly to an answer, it shows its work.

CoT is helpful because:

• It improves accuracy on multi-step reasoning tasks (often 5-10% improvement)
• It makes the agent's thinking transparent and debuggable
• It helps the LLM avoid rushing to conclusions

However, CoT has limitations:

• It increases token usage (longer responses)
• It doesn't improve performance on all tasks (only complex reasoning)
• It still can't fix hallucinations from lack of knowledge

2. ReAct: Reasoning + Acting (The Agent Framework)

ReAct interleaves reasoning with action. Instead of thinking of everything then acting, the agent thinks, acts, observes results, then thinks again based on what it learned.

ReAct is powerful because:

• Agents can verify their reasoning against reality
• If reasoning was wrong, they can correct it based on observation
• Tool calls are motivated by explicit reasoning
• It's interpretable — you can see why the agent took each action

3. Plan-and-Execute: Two-Phase Reasoning

Some tasks benefit from planning before acting. In Plan-and-Execute, the agent first creates a full plan, then executes it step by step.

Use Plan-and-Execute when:

• The task is complex with multiple steps
• There are dependencies between steps (some tasks must happen before others)
• You want to ensure comprehensive coverage of the task
• You want the user to see and approve the plan before execution

4. Tree-of-Thought: Exploring Multiple Paths

For problems where the solution path is uncertain, Tree-of-Thought explores multiple reasoning branches and selects the most promising ones.

Tree-of-Thought is useful for:

• Mathematical problem-solving
• Complex reasoning tasks where multiple solution paths exist
• Scenarios where the LLM might initially choose a suboptimal path

However, it's more computationally expensive (multiple LLM calls) and better for problems where verification is possible.

Comparison: Which Framework to Use?

Tool Use and Grounding: Connecting Agents to Reality

A language model without tools is just a text predictor. Tools are what make agents real. Tools connect the agent to databases, APIs, sensors, and the outside world.

Why Tools Matter

• Grounding: Agents can verify knowledge against reality
• Actions: Agents can modify the world, not just talk about it
• Freshness: Agents can access real-time information (stock prices, weather)
• Accuracy: Agents can use specialized tools (calculators, code execution)
• Delegation: Agents can offload computation to appropriate systems

Types of Tools

Implementing a Simple Tool: Weather Lookup

Best Practices for Tool Design

• Clear Names: Tool names should clearly indicate what they do
• Clear Docstrings: The agent uses the docstring to decide whether to call the tool
• Typed Arguments: Include type hints so the agent knows what to pass
• Error Handling: Tools should never crash; return error messages instead
• Reasonable Output: Tool output should be in a form the LLM can understand
• Feedback: Include information in the output that helps the agent decide next steps

Common Tool Patterns

Tool Chaining: Complex Operations from Simple Tools

Error Handling: Making Tools Robust

Planning and Task Decomposition

The difference between a capable agent and a floundering one often comes down to planning. Complex tasks require breaking them into subtasks, understanding dependencies, and executing in the right order.

Task Decomposition: The Core Skill

Given a goal, the agent must ask:

• What are the subgoals needed to achieve this goal?
• What information do I need to gather first?
• Are there any prerequisites or dependencies?
• What could go wrong at each step?
• How will I know if I've succeeded?

Hierarchical Planning

Agents work best with hierarchical plans — breaking problems from abstract to concrete:

Handling Dependencies

Not all subtasks can be done in parallel. Some depend on results from others:

Adaptive Planning: Replanning When Things Change

Agents should monitor if their plan is still valid and replan if needed:

• Assumption violation: A fact the plan depends on turned out to be wrong
• New information: Data discovered mid-plan suggests a better approach
• Tool failure: A tool the plan relied on is unavailable
• Resource constraint: Time or budget is running out

Memory Management: Building Agent Context

Memory is the agent's long-term knowledge. Without memory, each agent interaction is isolated. With good memory, agents build understanding over time.

Types of Agent Memory

Episodic Memory: Conversation History

The simplest form of memory is keeping the full conversation history:

Problem: Full conversation history grows too large. Eventually exceeds the LLM's context window.

Episodic Memory: Summarization and Sliding Window

Instead of storing everything, summarize old conversations or use a sliding window:

Semantic Memory: Vector-Based Retrieval

For large knowledge bases, agents use vector embeddings and semantic search:

State Memory: Progress Tracking

Agents need to track what they're doing and what they've accomplished:

Conversation Memory + Vector Memory Integration

Multi-Agent Systems: Specialization and Coordination

Some problems are too complex for a single agent. Multi-agent systems use multiple specialized agents that collaborate (or compete) to solve problems.

Why Multi-Agent Systems?

• Specialization: Different agents can specialize in different domains (research, writing, analysis)
• Scalability: Agents can work in parallel on different subproblems
• Robustness: If one agent fails, others can continue
• Diversity: Multiple agents with different reasoning styles may find better solutions
• Realistic: Mirrors how humans solve complex problems (teamwork)

Types of Multi-Agent Architectures

Example: Research Paper Writing Pipeline

Consensus-Based Decision Making

When multiple agents disagree, consensus mechanisms help:

CrewAI: A Framework for Multi-Agent Teams

CrewAI is a Python framework that simplifies building multi-agent teams:

Emergent Behavior in Multi-Agent Systems

Interestingly, multi-agent systems can exhibit emergent behavior — collective properties that arise from agent interactions but aren't explicitly programmed.

Examples:

• A team of agents independently working on subtasks naturally learns to avoid duplicate work
• Agents sharing findings naturally create higher-quality synthesis than any single agent
• Weak individual agents in a diverse team can outperform strong individual agents

Agent Frameworks: Tools for Building Agents

Building agents from scratch is complex. Frameworks abstract away boilerplate and best practices.

Major Agent Frameworks

LangChain: The Standard

LangChain is the most widely used agent framework. It provides:

• Predefined agent types (ReAct, OpenAI Functions, etc.)
• A large library of tools and integrations
• Memory management abstractions
• Chain-of-thought execution

Comparison: LangChain vs CrewAI

Building Your First Agent: Implementation Guide

Let's build a complete, working agent from scratch. This agent researches companies and generates investment summaries.

Key Implementation Considerations

• Error Handling: Tools should never crash; return error messages instead
• Rate Limiting: Don't overwhelm APIs; add delays if needed
• Timeout Protection: Set timeouts on tool calls to prevent hangs
• Logging: Log all agent decisions for debugging and auditing
• Cost Control: Monitor API costs; set spending limits if needed
• Testing: Test tools independently before adding to agent

Code Examples: Multiple Frameworks

Example 1: ReAct Agent with LangChain

Example 2: Tool-Calling Agent (Native Function Calls)

Example 3: Multi-Agent System with CrewAI

Reasoning Frameworks Comparison

Different frameworks suit different problems. Here's how to choose:

Decision Tree: Which Framework?

Memory Patterns in Production

How do production agents manage memory at scale?

Pattern 1: Summary + Sliding Window

Keep recent messages verbatim, summarize older ones:

Pattern 2: Hierarchical Memory

Different types of information at different levels:

Pattern 3: Fact-Based Memory

Extract and store discrete facts from conversations:

Evaluating Agent Performance

How do you know if your agent is good? Evaluation is critical but non-obvious.

Evaluation Metrics

Building an Evaluation Framework

Common Evaluation Pitfalls

• Only measuring final output: Good reasoning matters even if output is slightly off
• Ignoring token cost: An agent that solves everything in 10x tokens is impractical
• Not testing edge cases: Test error conditions, ambiguous inputs, adversarial examples
• Overfitting to benchmarks: Improve on the actual task, not the test set
• Ignoring human judgment: Sometimes LLM evaluation misses important aspects

Best Practices for Building Agents

Design Principles

• Explicit Goals: Agents should have clear, measurable goals. Vague goals lead to vague behavior.
• Bounded Reasoning: Set max iterations. An infinite loop is worse than failure.
• Graceful Degradation: When things go wrong, agents should fail safely and informatively.
• Observable Behavior: Log and monitor agent decisions. Black boxes are dangerous.
• Human Oversight: Critical actions should require human approval or logging.

Prompt Engineering for Agents

Error Handling and Robustness

Cost Management

• Monitor API Costs: Track LLM API calls; they're expensive at scale
• Use Caching: Cache tool results when possible (e.g., weather for the same location)
• Optimize Token Usage: Shorter prompts, relevant context only
• Batch Operations: Process multiple requests together when possible
• Cheaper Models: Use cheaper models for simple tasks, save expensive models for complex reasoning

Testing and Iteration

• Start with a simple agent, add complexity gradually
• Test each tool independently before integrating
• Build test suites covering normal and edge cases
• Use logging extensively during development
• Get feedback from actual users early

Interview Questions on AI Agents

If you're interviewing for agent-focused roles, you might encounter these questions:

Frequently Asked Questions

Practical Exercises

Summary: Key Takeaways

The Big Picture

• Agents are systems, not models: Built by combining LLMs, tools, memory, and reasoning frameworks.
• The agent loop is fundamental: Observe → Think → Act → Observe. Repeat until goal achieved.
• Grounding is critical: Agents without tools are just text generators. Tools connect agents to reality.
• Memory matters: Episodic, semantic, procedural, and state memory together enable learning over time.
• Design trumps complexity: A well-designed simple agent beats a complex one that doesn't work.

When to Use Agents

• Tasks requiring multiple steps and external tools
• Problems needing reasoning and adaptation
• Systems that must interact with dynamic environments
• Applications where transparency (showing reasoning) is important
• Domains where errors need graceful recovery

When NOT to Use Agents

• Simple classification or generation tasks (use LLM directly)
• When latency is critical and you can't afford LLM loops
• Fully deterministic workflows (use traditional software)
• When you need guaranteed correctness (agents aren't 100% reliable)

Getting Started

1. Pick a simple task (e.g., answer a frequently asked question)
2. Build a basic agent with 1-2 tools using LangChain
3. Test thoroughly with diverse inputs
4. Add complexity gradually (more tools, memory, reasoning)
5. Collect user feedback and iterate

Key Resources

• LangChain Documentation: https://python.langchain.com - Most comprehensive agent framework docs
• CrewAI GitHub: https://github.com/joaomdmoura/crewai - Multi-agent framework
• Anthropic Documentation: https://docs.anthropic.com - Claude API docs with agent examples
• Research Papers:
  • "ReAct: Synergizing Reasoning and Acting in Language Models" (Yao et al., 2023)
  • "Tool Learning with Foundation Models" (Qin et al., 2024)
  • "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models" (Wei et al., 2023)

Further Learning

Online Courses

• DeepLearning.AI: "Agentic Design Patterns with Claude" - Excellent practical course
• Anthropic: "Building with Claude" - Free resources on agent building

Books

• "Artificial Intelligence: A Guide for Thinking Humans" by Melanie Mitchell - Broader AI context
• "The Alignment Problem" by Brian Christian - Ethics and safety in AI systems

Community Resources

• GitHub Discussions - LangChain and CrewAI communities are active and helpful
• Discord servers - Many AI communities discussing agents and frameworks
• Academic conferences - ICLR, NeurIPS, ACL publish cutting-edge agent research