Skip to content
datarekha

Course · 9 chapters · 78 lessons

Agentic AI

Where Generative AI builds the model layer, Agentic AI builds autonomous systems on top of it: the patterns (reflection, tool use, planning, multi-agent), the protocols (MCP, A2A), the orchestration frameworks and SDKs, and the production concerns for agents that actually work.

The Agentic AI journey 0 / 78 completed
  1. Chapter 01

    Foundations

    6 lessons
  2. 01 What agentic AI means An agent is an LLM that can act, not just answer. Here's what that actually involves — and how it changes the engineering. Beginner5 min
  3. 02 Agentic design patterns Anthropic's canonical taxonomy — prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer — and the agent shape itself.… Intermediate8 min
  4. 03 Tools — defining, calling, validating Defining tools with JSON schema, validating arguments, handling errors, and the production patterns for reliable tool-using agents. Intermediate7 min
  5. 04 The Agent Harness The LLM is stateless — the harness is everything else. Learn what the runtime scaffolding around a model is, what each component does, and how to b… Intermediate9 min
  6. 05 Reflection Anthropic's name for the reflection pattern. How to make an LLM check its own work, the two ways to wire it, when same-model is enough vs. when a s… Intermediate6 min
  7. 06 ReAct, Plan-Execute, Reflexion The three agent reasoning loops every engineer should know in 2026: interleaved ReAct, upfront Plan-and-Execute, and self-correcting Reflexion. See… Intermediate8 min
  8. Chapter 02

    Protocols: MCP & A2A

    6 lessons
  9. 07 Model Context Protocol (MCP) The standard for plugging tools into agents. Write your integration once; every MCP-compatible client can use it. Intermediate6 min
  10. 08 AGENTS.md, Skills & Tools Three different ways to give an agent knowledge and power — always-on instructions, on-demand model-loaded skills, and runtime tool calls. What eac… Intermediate9 min
  11. 09 Advanced MCP primitives Tools, resources, and prompts are only half of MCP. Servers can also ask the user for input mid-call, run long jobs, and return UI. The 2026-07-28… Advanced8 min
  12. 10 MCP gateways & registries One MCP server is easy; an organization with dozens of servers and many clients is a mess. An MCP gateway is the fix — a proxy that aggregates serv… Advanced7 min
  13. 11 MCP vs A2A vs ACP vs ANP Four agent protocols arrived in barely a year — and most takes get them wrong. They aren't competitors; they're layers. Here's how MCP, A2A, ACP, a… Intermediate9 min
  14. 12 A2A — Agent2Agent Protocol MCP connects one agent to its tools. A2A connects independent, opaque agents to each other. A deep dive on the Agent Card, the task lifecycle, stre… Intermediate8 min
  15. Chapter 03

    Orchestration frameworks (LangChain, LangGraph, LlamaIndex)

    11 lessons
  16. 13 Models, prompts, parsers The practical LangChain foundation: chat models, named prompt templates, output parsers, LCEL composition, and the point where the abstraction earn… Beginner6 min
  17. 14 Chains & LCEL LangChain Expression Language is the pipe-operator DSL for stitching Runnables together. Branching, fan-out, streaming, batching — all on the same… Intermediate8 min
  18. 15 RAG with LangChain LangChain's RAG pieces fit together cleanly for prototypes. Document loaders, text splitters, embeddings, vector stores, retrievers — wired end-to-… Intermediate8 min
  19. 16 Build agents from scratch Explicit state graphs for the workflows LCEL can't express cleanly — branching, loops, retries, and pauses. The mental model and the smallest possi… Intermediate9 min
  20. 17 Nodes, edges, state State is a TypedDict; nodes return partial updates; reducers decide how to merge. The add_messages reducer is the building block for every chat-s… Intermediate7 min
  21. 18 Persistence & streaming Checkpointers save state after every step — enabling resumable agents, multi-turn conversations, time-travel debugging, and streaming intermediate… Advanced7 min
  22. 19 Human-in-the-loop Pause the graph, let a human review or edit, resume from where it stopped. The pattern is "LLM proposes, human disposes" — and it's what makes agen… Advanced6 min
  23. 20 Indexes, query engines & retrievers LlamaIndex turns documents into a queryable knowledge base through loaders, nodes, indexes, retrievers, and response synthesizers, with practical g… Beginner7 min
  24. 21 Event-driven Workflows Build LlamaIndex applications as typed, event-driven workflows: steps, branching, loops, fan-out, fan-in, testing, and the production traps that ma… Intermediate8 min
  25. 22 FunctionAgent & ReActAgent Turn LlamaIndex query engines into tools an agent can choose, compare FunctionAgent with ReActAgent, and understand the Workflow loop behind agenti… Intermediate7 min
  26. 23 LlamaParse — document parsing A PDF can look perfect to a human and still poison RAG. LlamaParse uses layout-aware parsing and OCR to turn tables, columns, and scans into usable… Beginner6 min
  27. Chapter 04

    Memory, planning & self-improvement

    7 lessons
  28. 24 Agent Memory How agents remember across turns and sessions. The cognitive-science taxonomy production systems borrow — working, episodic, semantic, procedural —… Intermediate8 min
  29. 25 Context engineering The production discipline of deciding what an agent sees, when it sees it, and what stays outside the context window. Compaction, isolation, retrie… Intermediate8 min
  30. 26 ReWOO: plan-execute without observation ReAct re-reads the whole growing transcript on every step — expensive and easily derailed. ReWOO plans the entire task up front, runs the tools, th… Advanced8 min
  31. 27 HTN & evolutionary planning When an LLM invents a risky step or skips a prerequisite, hierarchical task network planning replaces improvisation with known methods and executab… Advanced8 min
  32. 28 Tree of Thoughts Chain-of-thought reasons in one straight line — if an early step is wrong, the whole chain fails. Tree of Thoughts turns reasoning into deliberate… Advanced8 min
  33. 29 Skill libraries & sleep-time compute Most agents re-derive the same procedures on every task. A skill library lets an agent solve something once, save the solution as a reusable skill,… Advanced8 min
  34. 30 Self-improving agents A self-improving agent generates attempts, verifies them, keeps the good ones, and learns from them. Learn the mechanism behind STaR, evolutionary… Advanced8 min
  35. Chapter 05

    Multi-agent systems

    6 lessons
  36. 31 Multi-agent: supervisor & swarm How single agents, supervisors, swarms, and hierarchies divide work, what multi-agent orchestration actually buys you, and why most systems should… Intermediate8 min
  37. 32 Multi-agent debate & voting A single agent can be confidently wrong. Ask several and either let them vote or let them argue: independent errors cancel under majority vote, and… Advanced8 min
  38. 33 Group chat & the blackboard pattern Agents on a team have to do two things: share what they know, and decide who acts next. There are two classic ways to wire that — broadcast group c… Advanced8 min
  39. 34 Agent negotiation & economies When agents belong to different owners, cooperation cannot be assumed. Learn how bargaining, contract-net task allocation, auctions, and mechanism… Advanced8 min
  40. 35 Generative agents: simulations Most agents do tasks. Generative agents do something stranger — they simulate believable human behavior. Park et al.'s Smallville put 25 LLM agents… Advanced8 min
  41. 36 Why multi-agent systems fail Multi-agent systems fail because coordination adds its own bugs: unclear roles, lossy hand-offs, correlated mistakes, and missing verification. The… Advanced8 min
  42. Chapter 06

    Agent SDKs & runtimes

    13 lessons
  43. 37 Agents, handoffs & guardrails A small, explicit framework for production agents: Agents, Runner, tools, handoffs, guardrails, and sessions, with a worked triage example and the… Intermediate8 min
  44. 38 MAF overview & first agent Microsoft Agent Framework is Microsoft's unified Python and .NET SDK for agents, tools, threads, and workflows. Learn its execution model, Azure st… Intermediate7 min
  45. 39 Adding tools How Python functions become MAF tools, when to require human approval, and the hosted tools (code interpreter, file search, MCP) you get for free. Intermediate6 min
  46. 40 Workflows MAF workflows are graphs of agents (executors) for sequential, parallel, conditional, and looping orchestration. Here's a 3-agent planner → executo… Advanced8 min
  47. 41 Middleware & guardrails Middleware in MAF wraps around agent invocations and tool calls. Use it for logging, rate limiting, PII scrubbing, and termination. Order matters. Advanced7 min
  48. 42 Install & first agent Google ADK is a Gemini-first framework for building, inspecting, and deploying agents. Learn the LlmAgent, tools, sessions, runners, event streams,… Intermediate6 min
  49. 43 Multi-tool agent Defining tools in Google ADK, using multiple tools in one agent, and the built-in tools (Google Search grounding, code execution) you get for free. Intermediate7 min
  50. 44 Workflow patterns ADK gives you SequentialAgent, ParallelAgent, and LoopAgent for multi-agent orchestration. Here's a research → write → review pipeline. Advanced7 min
  51. 45 Deployment Three paths from local ADK agent to production. Agent Engine for fastest, Cloud Run for portability, GKE for full control. The trade-offs, with com… Advanced6 min
  52. 46 CrewAI — role-based crews CrewAI models a multi-agent system as a team you hire: each agent gets a role, a goal, and a backstory, each does a task, and a Process decides how… Intermediate7 min
  53. 47 Claude Agent SDK The Claude Agent SDK gives Python and TypeScript agents the harness behind Claude Code: a real tool loop, filesystem, shell, MCP, subagents, contex… Intermediate7 min
  54. 48 AutoGen: conversational multi-agent AutoGen treats a multi-agent system as a conversation: agents exchange messages, execute work, review results, and decide who speaks next. Learn th… Intermediate8 min
  55. 49 Agent runtimes: Agno & Mastra Agent runtimes package model access, memory, tools, knowledge, workflows, evaluation, and operational hooks behind one language-native API. Compare… Intermediate7 min
  56. Chapter 07

    Multi-agent theory

    5 lessons
  57. 50 Consensus & Byzantine fault tolerance At 3:00 a.m., four agents must agree whether to issue a $10,000 refund while one may be compromised. Consensus explains agreement under delay and f… Advanced7 min
  58. 51 Multi-agent reinforcement learning When several agents learn at once, each agent changes the world the others are trying to learn. This guide explains non-stationarity, credit assign… Advanced7 min
  59. 52 Swarm intelligence & optimization A practical guide to swarm intelligence, particle swarm optimization, and ant colony optimization: how local rules create useful global search, whe… Advanced7 min
  60. 53 Theory of mind for agents Theory of mind is an agent's ability to model another agent's beliefs, goals, knowledge, and uncertainty, including beliefs that are wrong. Learn t… Advanced7 min
  61. 54 Decision-making under uncertainty How rational agents trade off uncertain outcomes, information costs, risk, and irreversible actions. Advanced12 min
  62. Chapter 08

    Agents in Production

    17 lessons
  63. 55 Agent Security An LLM can't reliably tell instructions from data, so any content it reads can hijack it. Learn the lethal trifecta, OWASP excessive agency, and wh… Intermediate9 min
  64. 56 How agents authenticate each other When agents call other agents and tools on your behalf, a claimed name is not security. Learn machine identity, OAuth, mTLS, scoped authorization,… Intermediate8 min
  65. 57 Token theft & runtime authorization Keep API keys and OAuth tokens out of model context, then authorize every tool call at runtime. Build a safe fake-token lab and learn vault injecti… Intermediate10 min
  66. 58 MCP tool poisoning & supply-chain security Threat-model the full MCP trust boundary: malicious tool metadata, cross-server shadowing, post-approval rug pulls, confused-deputy authorization,… Advanced10 min
  67. 59 Evaluating agents Agents can reach the right answer through a wrong, wasteful, or dangerous path. Evaluate the outcome, the trajectory, and the real side effects, th… Intermediate8 min
  68. 60 Agent benchmarks & eval-driven dev Static QA benchmarks do not measure an agent well: you need end-to-end task completion in a real environment, verified outcomes, and repeatable reg… Advanced9 min
  69. 61 Observability & tracing An agent can be wrong, slow, or expensive for reasons hidden behind its final answer. Traces show every model call, tool call, retry, token, and mi… Intermediate7 min
  70. 62 OpenTelemetry for GenAI A practical guide to tracing agent runs with OpenTelemetry and GenAI semantic conventions: span trees, token and cost accounting, tool calls, conte… Advanced7 min
  71. 63 Cost & latency control A practical guide to controlling agent spend and response time with routing, caching, context pruning, budgets, and the right workflow shape. Intermediate7 min
  72. 64 Durable execution for agents An agent run is a long workflow of LLM calls, tool calls, waits, and approvals. Durable execution records progress so crashes do not erase work, wh… Advanced8 min
  73. 65 Agent safety controls Prompt-level safety asks the model to behave — not enough for an autonomous agent that can delete data, send money, or deploy code. Engineered cont… Advanced8 min
  74. 66 The coding-agent workbench A chatbot answers; a coding agent must ship working code to a real repository — and that's where reliability collapses. The fix isn't a smarter mod… Advanced9 min
  75. 67 Production agent architecture A practical blueprint for building agents whose reasoning, tools, state, security, and failure recovery remain understandable in production. Intermediate13 min
  76. 68 Reliability for agent side effects How to make agent retries safe when the tools can charge, send, delete, or otherwise change the world. Advanced12 min
  77. 69 CI/CD for agents Ship prompts, tools, models, and policies as one tested release instead of discovering their interactions in production. Advanced13 min
  78. 70 Data governance for agents Control what an agent may see, remember, send, and leave behind before a helpful workflow becomes a data leak. Intermediate12 min
  79. 71 Designing human-agent interaction A practical guide to building agent interfaces people can trust, interrupt, correct, and recover from. Intermediate12 min
  80. Chapter 09

    Frameworks & Tooling

    7 lessons
  81. 72 Mem0 — a memory layer for agents How Mem0 extracts salient facts from conversations and retrieves only the relevant ones at the next turn, giving agents durable personalized memory… Intermediate7 min
  82. 73 FastMCP — build MCP servers fast A Pythonic framework that turns ordinary functions into MCP tools, resources, and prompts with simple decorators — so you can expose your own data… Intermediate8 min
  83. 74 Code execution with MCP When an agent has hundreds of MCP tools or large tool results, let it write code that calls and filters them outside the context window. The result… Intermediate7 min
  84. 75 Firecrawl — web data for LLMs & RAG Turn any URL into clean, LLM-ready Markdown. Firecrawl handles JS rendering, boilerplate removal, pagination, and full-site crawls so your RAG pipe… Intermediate7 min
  85. 76 Computer-use & browser agents Most software has no API. Computer-use agents drive a screen the way a person does — read a screenshot, click, type, repeat — so they can operate a… Advanced8 min
  86. 77 Voice agents (realtime) A text agent has seconds to respond; a voice agent has about half a second, or the conversation feels broken. Real-time voice is its own discipline… Advanced8 min
  87. 78 Multimodal agents Build agents that can reason over images, documents, and audio without losing control of cost, coordinates, or trust. Intermediate12 min
  88. End of section 0 / 78 complete

    Make it stick — pass every quiz.

    Each lesson has a short quiz at the bottom. Passing the quiz is what marks the lesson complete and counts toward your certificate.

    Section complete 78 / 78 lessons

    Nice work — you finished Agentic AI.

    Certificates are earned per learning path, not per section. Here's where this section takes you:

FAQCommon questions

Agentic AI — frequently asked questions

Straight answers to the questions people ask most about agentic ai.

What makes an AI agent different from a chatbot?

An agent doesn't just answer — it plans and acts in a loop: it calls tools, observes the results, and decides the next step until a goal is met. A chatbot produces one reply; an agent can search, run code, query a database, and chain those steps autonomously.

What is the Model Context Protocol (MCP)?

MCP is an open standard for connecting AI models to tools and data sources through a uniform interface, so any MCP-compatible client can use any MCP server. It acts like a universal adapter that replaces bespoke, per-integration glue code for agent tooling.

What's the difference between LangChain and LangGraph?

LangChain offers building blocks and chains for composing LLM apps; LangGraph models an agent as an explicit graph of nodes and edges with shared state, which makes loops, branching, retries, and human-in-the-loop control far easier to reason about. Use LangGraph when the control flow gets complex.

Why do multi-agent systems often fail?

Common failure modes are agents losing shared context, compounding each other's errors over long chains, looping without progress, and ballooning cost and latency. Reliability usually comes from constraining each agent's scope, adding verification steps, and keeping the control flow explicit rather than fully open-ended.

What are the main agent design patterns?

The core patterns are reflection (the model critiques and revises its own output), tool use (calling external functions), planning (decomposing a goal into steps), and multi-agent collaboration (specialised agents working together). Most production agents combine a few of these.