About Agentic AI
Agentic AI is the practice of building systems that don't just answer a prompt, but
pursue a goal: they plan, use tools, observe results, and adjust until the job is
done. This course starts with What Is Agentic AI? — how agents differ
from chatbots and workflows, and what the core agent loop looks like — then the
LLM Foundations & Prompting skills that every agent depends on.
Next you'll give models the ability to act. Tool Use & Function
Calling teaches how agents call APIs, run code, and interact with the outside
world, while Reasoning & Planning covers patterns like ReAct,
task decomposition, and self-reflection. You'll then handle what agents need to
remember with Memory & Context and ground their answers in real
knowledge with Retrieval-Augmented Generation.
With the building blocks in place, you'll assemble them using
Agent Frameworks such as LangGraph and the OpenAI and Anthropic
SDKs, scale up to Multi-Agent Systems where specialized agents
collaborate, and connect agents to external services through the
Model Context Protocol (MCP) & Integrations.
Finally, you'll learn how to make agents trustworthy and production-ready:
Evaluation & Observability to measure and debug behavior,
Safety & Guardrails to keep agents within bounds, and
Deploying Agents to run them reliably and affordably at scale.
Basic Python and a working knowledge of how LLMs are used (for example through an API)
will help, and the Introduction to AI
course is a good place to start if you're new to the field. Each module builds
directly on the last, so we recommend going in order.
Content
12 modules
01
What Is Agentic AI?
How agents differ from chatbots and fixed workflows, the core perceive-plan-act loop, levels of autonomy, and real-world agent use cases.
AI Agents
Agent Loop
Autonomy
02
LLM Foundations & Prompting
The model capabilities agents build on: context windows, system prompts, structured outputs, and prompting techniques that make behavior reliable.
LLMs
System Prompts
Structured Output
03
Tool Use & Function Calling
Letting models act: defining tools, passing arguments as JSON, running code, calling APIs, and handling tool errors gracefully.
Function Calling
APIs
Code Execution
04
Reasoning & Planning
Patterns that help agents think before acting: chain-of-thought, ReAct, task decomposition, self-reflection, and when to replan.
ReAct
Task Decomposition
Reflection
05
Memory & Context
Short-term and long-term memory, managing the context window, summarization, and storing what an agent learns between sessions.
Short-Term Memory
Long-Term Memory
Context Engineering
06
Retrieval-Augmented Generation
Grounding agents in your own data with embeddings, vector databases, chunking, and retrieval strategies — including agentic RAG.
RAG
Embeddings
Vector Databases
07
Agent Frameworks
Building agents faster with orchestration frameworks and SDKs: graphs, state, control flow, and choosing when not to use a framework at all.
LangGraph
Agent SDKs
Orchestration
08
Multi-Agent Systems
Designing teams of specialized agents: supervisors and workers, handoffs, shared state, and the trade-offs of adding more agents.
Multi-Agent
Handoffs
Supervisor Pattern
09
MCP & Integrations
Connecting agents to external tools and data with the Model Context Protocol, building MCP servers, and integrating with real services.
MCP
Integrations
Tool Servers
10
Evaluation & Observability
Measuring whether an agent actually works: task success metrics, test datasets, LLM-as-judge, tracing, and debugging multi-step runs.
Evals
Tracing
LLM-as-Judge
11
Safety & Guardrails
Keeping agents within bounds: prompt injection defenses, permissions and sandboxing, human-in-the-loop approvals, and handling failure modes.
Guardrails
Prompt Injection
Human-in-the-Loop
12
Deploying Agents
Taking agents to production: long-running tasks, cost and latency control, rate limits, monitoring, and iterating safely after launch.
Deployment
Cost Control
Monitoring
What You Can Do After This Course
By the end of the curriculum you'll have shipped five real projects and covered the
full path from a single tool-calling model to a deployed, monitored agent system.
Concretely, you'll be able to:
Explain how agents work — the difference between chatbots, workflows, and agents, and the loop that drives them.
Give models tools — define functions, call APIs, execute code, and handle errors so agents can take real actions.
Design reasoning and planning — apply ReAct, decomposition, and reflection to solve multi-step tasks.
Add memory and knowledge — manage context, persist state, and ground agents with retrieval over your own data.
Build with frameworks and MCP — orchestrate agents with modern SDKs and connect them to external services.
Coordinate multi-agent systems — split work across specialized agents and know when a single agent is enough.
Evaluate, secure, and ship — test agent quality, defend against prompt injection, and deploy with monitoring and cost controls.
Show proof of skill — a research assistant agent, a RAG-powered support agent, a coding agent, a multi-agent content team, and an MCP-powered personal assistant.