Introduction to
Agentic AI
Before writing a single line of agent code, you need a crystal-clear mental model of what agentic AI actually is — and why it represents a fundamentally different paradigm from the AI you've used before. Get this right and everything else in this course clicks into place.
From Answering to Acting
An AI agent is a system that uses a large language model as its core reasoning engine to pursue a goal — not by generating a single response, but by running an autonomous loop: perceiving its environment, deciding what to do, taking actions via tools, observing the results, and continuing until the goal is met or a stopping condition is reached.
Lilian Weng's foundational 2023 overview identifies three capabilities that elevate an LLM into an agent: planning (breaking a goal into subgoals and sequencing steps), memory (retaining context across steps), and tool use (calling external APIs, running code, reading files). No single capability is sufficient on its own — it is their combination operating inside an automated loop that defines the agent.
Anthropic's agent documentation adds a production-focused framing: agents are distinguished by the degree to which they operate with minimal human interaction per step. The defining characteristic is not what the agent can do — it's how independently it does it.
ReAct: Reason, Then Act
The dominant pattern for implementing the agent loop was formalized in the ReAct paper (Yao et al., 2022), published at ICLR 2023. ReAct stands for Reasoning + Acting, and it describes a specific interleaving: the model generates a Thought (explicit reasoning about what to do), then an Action (a tool call or decision), then observes the Observation (the tool's output), and repeats until it can produce a final Answer.
Prior approaches either did reasoning without acting (chain-of-thought prompting) or acting without explicit reasoning (action-only agents). ReAct's contribution was showing that making the reasoning visible and interleaved with actions dramatically improves performance on multi-step tasks — and makes agent behavior easier to debug and interpret.
"What is the population of the capital of France, and how has it changed since 2000?"
I need to find the capital of France first, then look up its population data.
web_search("capital of France population 2000 2024")
Paris is the capital. Population data found: 2000 ~2.1M city / 2024 ~2.06M city.
I have enough data. Paris population declined slightly. I can now answer.
Paris (population ~2.06M in 2024) saw a slight decline from ~2.1M in 2000...
This pattern — alternating explicit reasoning steps with grounded tool calls — is the foundation of how modern agent frameworks (LangChain, LangGraph, the Anthropic SDK's tool use loop) work under the hood. When you call a tool in Claude, you are participating in a ReAct-style loop.
The Real Distinction: Human-in-the-Loop vs. Autonomous
By 2026, consumer AI products have blurred the surface features that once separated "chatbots" from "agents." ChatGPT, Claude.ai, and Gemini all offer memory, multi-turn context, file uploads, web search, and even code execution. So the old framing — "agents have tools and memory, chatbots don't" — is no longer meaningful.
The meaningful distinction is who drives each step of the loop:
❌ You decide every next step
The underlying LLM is always a stateless function — it takes a context window in and produces tokens out. The "memory" that consumer products provide is a product layer that injects conversation history back into the prompt. What makes an agent is the automated loop that runs this function repeatedly, with tool results fed back in, without requiring a human prompt at each iteration.
Four Architectural Patterns
Lilian Weng's survey categorizes agents by their architecture — specifically, how they balance speed, memory, and reasoning depth. These categories map directly to design decisions you will make when building agents.
| Type | Memory | Planning | Best For | Trade-off |
|---|---|---|---|---|
| Reactive | None | None | Classifiers, routers, filters | Fast, but can't handle novel situations |
| Deliberative | Full | Full | Research, coding, multi-step reasoning | Slower, higher token cost |
| Hybrid | Selective | Selective | Production agents with mixed task types | More complex to implement and debug |
| Multi-Agent | Distributed | Distributed | Large workflows needing parallelism | Orchestration overhead, harder to debug |
How Much Autonomy Does Your Agent Need?
Anthropic's agent documentation frames autonomy as a spectrum, not a binary. Real deployments live somewhere between a fully passive tool and a fully autonomous system. Understanding this spectrum is essential for making safe, appropriate design decisions.
Agents Add Complexity — Make Sure It's Worth It
Not every AI task needs an agent. An agent adds orchestration overhead, token cost, latency, and surface area for failure. The decision framework comes directly from Anthropic's agent documentation: build an agent when the task genuinely requires multi-step decision-making that cannot be collapsed into a well-crafted single prompt.
| Use Case | Use an Agent? | Reason |
|---|---|---|
| Summarize a document I've already uploaded | No | A single well-crafted prompt handles this. Agent overhead is waste. |
| Research a topic across multiple live sources, synthesize findings, and write a report | Yes | Requires multi-step search, reading, filtering, and synthesis. No single prompt can do this. |
| Translate a paragraph from English to French | No | One inference, one output, no tools needed. |
| Monitor a codebase, run tests on PR merge, file issues on failure, and notify the team | Yes | Requires tool use (git, CI, issue tracker, Slack), conditionals, and multi-step orchestration. |
| Answer a customer's question about a product using a knowledge base | Maybe | A RAG pipeline may suffice. Add agent loop only if multi-hop retrieval or follow-up actions are needed. |
How Agents Break in Practice
Understanding how agents fail is as important as understanding how they work. Anthropic's documentation identifies several classes of failure that appear consistently in production deployments. Designing against these from the start saves significant debugging time later.
Verified References
Every claim in this section is grounded in one of these sources. No content is generated from model training data alone.
| Source | Type | Covers | Recency |
|---|---|---|---|
| Lilian Weng — LLM Powered Autonomous Agents | Blog / Survey | Agent pillars, agent types, ReAct pattern overview | June 2023 |
| Yao et al. — ReAct (arXiv:2210.03629) | Academic paper | Reason + Act loop, Thought/Action/Observation trace, ICLR 2023 | Oct 2022 / ICLR 2023 |
| Anthropic — Tool Use Documentation | Official docs | Agent definition, autonomy guidance, failure modes, orchestrator/subagent framing | Maintained 2024–2026 |
Section 01 Quiz
8 questions covering all theory blocks. Select one answer per question, then submit.