Agentic AIIntermediate
AI Agent Architecture — ReAct, Memory, Planning and Multi-Agent Systems
This course covers AI agent theory and architecture at an intermediate level, serving as a direct prerequisite to the "Build AI Agents with LangChain" course. The material is organized with increasing difficulty: early chapters build conceptual foundations (what an agent is, the perception-action loop, the role of the LLM as a decision engine), while later chapters address specific architectural patterns. The course examines in depth the ReAct (Reasoning + Acting) paradigm, short-term and long-term memory patterns, planning strategies (CoT, Tree-of-Thought, sequential vs. parallel tasks), and multi-agent system architecture with an orchestrator. A dedicated module covers Tool-augmented LLM: methods for equipping agents with tools, function calling, and tool-invocation decision-making. The course does not cover implementation in specific frameworks (LangChain, AutoGen, CrewAI) — that is the scope of the next course. It is also not a course on prompting or model fine-tuning. Prerequisites: basic familiarity with LLMs and prompting (user level), ability to read Python pseudocode. A graduate understands agent architecture from input to output, can evaluate trade-offs between planning patterns, and selects the appropriate memory architecture for a given system's requirements.
Chapters
MODULE 01AI Agent — Architecture, Not a Chatbot
A foundational chapter: how an AI agent differs from a chatbot, what the pillars of agent architecture are (Planning, Memory, Tool Use), and where the line runs between a genuine agent and a product with a fashionable label.
AI Agent — Architecture, Not a Chatbot
- 1.1From Chatbot to Agent — Architectural Difference
- 1.2Three Pillars of an Agent: Planning, Memory, Tool Use
- 1.3The Agent Loop: Observe → Think → Act → Observe
- 1.4Agenticity as a Spectrum — Not a Binary Switch
- 1.5Native LLM Limitations: No Memory, Finite Context, No World Access
- 1.6"Agent washing" — How to Spot a Fake Agent
MODULE 02Reasoning — How an LLM Thinks Before Acting
This chapter covers LLM reasoning enhancement techniques: Chain-of-Thought, zero-shot vs few-shot CoT, Tree of Thoughts with BFS/DFS search strategies, and the limits and pitfalls of self-correction.
Reasoning — How an LLM Thinks Before Acting
MODULE 03ReAct — the Reasoning and Acting Loop
The ReAct pattern (Reasoning + Acting) — the Thought→Action→Observation loop architecture, HotpotQA and FEVER benchmarks, ALFWorld and WebShop decision environments, the Reflexion mechanism, and production implementation with bounded loops and error handling.
ReAct — the Reasoning and Acting Loop
- 3.1Problem: reasoning without acting vs acting without reasoning
- 3.2The Thought → Action → Observation pattern — anatomy of one iteration
- 3.3ReAct on knowledge-intensive tasks — HotpotQA and FEVER as case studies
- 3.4ReAct on decision-making tasks — ALFWorld and WebShop
- 3.5Reflexion — an agent learning from its own mistakes via self-reflection
- 3.6Bounded ReAct in production — max_steps, infinite loop detection, error trace as observation
MODULE 04Agent Memory — From Context Window to Vector Store
This chapter covers all memory layers of an AI agent: from the stateless nature of LLMs and the role of the context window, through the four memory types, long-term memory with embeddings and vector stores, memory stream with retrieval scoring, to reflection as a higher-order memory synthesis mechanism.
Agent Memory — From Context Window to Vector Store
- 4.1LLM is stateless — memory is an architectural trick
- 4.2Four agent memory types: sensory, working, episodic, semantic
- 4.3Short-term memory — context window as agent RAM and its limits
- 4.4Long-term memory — embeddings, vector store and semantic retrieval
- 4.5Memory stream and retrieval scoring: recency × importance × relevance
- 4.6Reflection — higher-order memory synthesis
MODULE 05Tool-Augmented LLM — Tools, Functions and the Environment
This chapter covers the architecture of tool-augmented LLMs: from fundamentals and tool taxonomy, through JSON schema contracts, learning when and how to call tools (Toolformer, MRKL), a safe dispatcher, to error handling and function-name hallucinations.
Tool-Augmented LLM — Tools, Functions and the Environment
- 5.1Why an LLM Needs Tools — the Knowledge and Capability Gap
- 5.2Tool Taxonomy: Read-Only vs Effectful, Deterministic vs Stochastic
- 5.3JSON Schema of a Tool — the Contract Between LLM and Environment
- 5.4Toolformer and MRKL — How an LLM Learns When and How to Call Tools
- 5.5Dispatcher — Parsing LLM Output and a Safe Tool Registry
- 5.6Tool Error Handling and Function Name Hallucinations