datarekha
Section 7 chapters · 71 of 71 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 / 71 completed
  1. Chapter 01

    Foundations

    18 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 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. Ho… Intermediate8 min
  5. 04 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
  6. 05 HTN & evolutionary planning Free-form LLM planning is flexible but unpredictable. Hierarchical Task Network planning brings classical-AI structure — decompose a goal into subt… Advanced8 min
  7. 06 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
  8. 07 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
  9. 08 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
  10. 09 Self-improving agents Most agents are static — fixed weights, fixed skills. A self-improving agent closes a loop: generate attempts, evaluate them, keep and learn from t… Advanced8 min
  11. 10 Tools — defining, calling, validating Defining tools with JSON schema, validating arguments, handling errors, and the production patterns for reliable tool-using agents. Intermediate7 min
  12. 11 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
  13. 12 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
  14. 13 Model Context Protocol (MCP) The emerging standard for plugging tools into agents. Write your integration once; every MCP-compatible client can use it. Intermediate6 min
  15. 14 Advanced MCP primitives Tools, resources, and prompts are only half of MCP. The protocol is bidirectional and interactive: a server can call back to the host's LLM (sampli… Advanced8 min
  16. 15 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
  17. 16 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
  18. 17 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
  19. 18 How agents authenticate each other When agents call other agents and tools on your behalf, 'it said it was the billing agent' is not security. Identity, authentication, scoped author… Intermediate8 min
  20. Chapter 02

    Multi-agent systems

    6 lessons
  21. 19 Multi-agent: supervisor & swarm Supervisor, swarm, and hierarchical orchestration — and the harder question of when NOT to go multi-agent. Most tasks are better served by a single… Intermediate8 min
  22. 20 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
  23. 21 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
  24. 22 Agent negotiation & economies Orchestration assumes one owner and a shared goal. But agents increasingly meet across that boundary — your buyer agent and someone else's seller a… Advanced8 min
  25. 23 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
  26. 24 Why multi-agent systems fail Multi-agent systems fail more often than their hype suggests — and not just because the models are weak. Coordination itself adds new failure modes… Advanced8 min
  27. Chapter 03

    Multi-agent theory

    4 lessons
  28. 25 Consensus & Byzantine fault tolerance The LLM-agent lessons assumed cooperative agents under one owner. Classical multi-agent systems studied a harder problem: how do distributed, possi… Advanced7 min
  29. 26 Multi-agent reinforcement learning Single-agent RL has one learner in a fixed environment. Multi-agent RL has many agents learning at once — which breaks that assumption. From any on… Advanced7 min
  30. 27 Swarm intelligence & optimization Most multi-agent design has agents pursuing goals. Swarm intelligence is a different angle: global optimization that emerges from many simple agent… Advanced7 min
  31. 28 Theory of mind for agents To coordinate, compete, or communicate well, an agent benefits from modeling what other agents think — their beliefs, goals, and knowledge, which m… Advanced7 min
  32. Chapter 04

    Orchestration frameworks (LangChain, LangGraph, LlamaIndex)

    11 lessons
  33. 29 Models, prompts, parsers The minimum-viable LangChain — chat models behind a unified interface, prompt templates, output parsers, and when you actually need any of it. Beginner6 min
  34. 30 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
  35. 31 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
  36. 32 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
  37. 33 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
  38. 34 Persistence & streaming Checkpointers save state after every step — enabling resumable agents, multi-turn conversations, time-travel debugging, and streaming intermediate… Advanced7 min
  39. 35 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
  40. 36 Indexes, query engines & retrievers LlamaIndex is the data framework for LLM apps — it turns documents into a queryable index through swappable components: loaders, node parsers, inde… Beginner7 min
  41. 37 Event-driven Workflows Workflows are how modern LlamaIndex composes multi-step LLM apps: typed Events flowing between async Steps. The recommended way to build everything… Intermediate8 min
  42. 38 FunctionAgent & ReActAgent Turn a LlamaIndex index into a tool an agent can call. FunctionAgent (native function-calling) vs ReActAgent (text-based ReAct), both built on Work… Intermediate7 min
  43. 39 LlamaParse — document parsing Naive PDF text extraction destroys tables, columns, and layout — and poisons your RAG. LlamaParse uses vision models to turn messy documents into c… Beginner6 min
  44. Chapter 05

    Agent SDKs & runtimes

    13 lessons
  45. 40 Agents, handoffs & guardrails A lightweight, production-minded agent framework: Agents, Runner, Tools, Handoffs, Guardrails, and Sessions. The default starting point for many pr… Intermediate8 min
  46. 41 MAF overview & first agent MAF is Microsoft's unified agent framework, replacing AutoGen and Semantic Kernel. Here's the shape of a first agent and the four building blocks y… Intermediate7 min
  47. 42 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
  48. 43 Workflows MAF workflows are graphs of agents (executors) for sequential, parallel, conditional, and looping orchestration. Here's a 3-agent planner → executo… Advanced8 min
  49. 44 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
  50. 45 Install & first agent Google's Agent Development Kit is the Gemini-native agent framework. LlmAgent, tools, sessions, runners — plus a web UI for local dev. Here's the s… Intermediate6 min
  51. 46 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
  52. 47 Workflow patterns ADK gives you SequentialAgent, ParallelAgent, and LoopAgent for multi-agent orchestration. Here's a research → write → review pipeline. Advanced7 min
  53. 48 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
  54. 49 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
  55. 50 Claude Agent SDK The Claude Agent SDK is the production harness behind Claude Code, available standalone. It ships the loop that already works — gather context, tak… Intermediate7 min
  56. 51 AutoGen: conversational multi-agent Where LangGraph models agents as a graph and CrewAI as roles, AutoGen models them as agents that talk. Microsoft's framework for multi-agent conver… Intermediate8 min
  57. 52 Agent runtimes: Agno & Mastra The first agent frameworks were orchestration libraries you wire together. A newer class — agent runtimes — ships the whole production stack (model… Intermediate7 min
  58. Chapter 06

    Agents in Production

    13 lessons
  59. 53 Agent Memory How agents remember across turns and sessions. The cognitive-science taxonomy production systems borrow — working, episodic, semantic, procedural —… Intermediate8 min
  60. 54 Context engineering The headline 2026 agent skill: curating what's in the context window. Compaction, isolation, and retrieval keep long-running agents lean, coherent,… Intermediate8 min
  61. 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
  62. 56 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
  63. 57 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
  64. 58 Evaluating agents An agent has a loop, side effects, and non-deterministic intermediate states — so a single input/output check isn't enough. Evaluate the trajectory… Intermediate8 min
  65. 59 Agent benchmarks & eval-driven dev Static QA benchmarks don't measure an agent — you need end-to-end task completion in a real environment. SWE-bench, GAIA, WebArena, OSWorld, why ag… Advanced9 min
  66. 60 Observability & tracing You can't debug an agent you can't see. Traces capture every LLM call, tool call, token, and millisecond of a run — so you can find the retry loop,… Intermediate7 min
  67. 61 OpenTelemetry for GenAI Agents are hard to debug — non-deterministic, multi-step, and spread across model calls, tools, and retrieval. OpenTelemetry's GenAI semantic conve… Advanced7 min
  68. 62 Cost & latency control Agents make many model calls per task, so cost and latency multiply fast. The levers that cut agent spend 40–70%: routing, caching, token budgets,… Intermediate7 min
  69. 63 Durable execution for agents An agent run isn't a request-response — it's a long workflow of LLM calls, tool calls, waits, and approvals. If the process crashes mid-run you los… Advanced8 min
  70. 64 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. You need engine… Advanced8 min
  71. 65 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
  72. Chapter 07

    Frameworks & Tooling

    6 lessons
  73. 66 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
  74. 67 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
  75. 68 Code execution with MCP Instead of loading every tool and routing every result through the context window, let the agent write code that calls tools out-of-context. The pa… Intermediate7 min
  76. 69 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
  77. 70 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
  78. 71 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
  79. End of section 0 / 71 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 71 / 71 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.

Skip to content