Most "agentic AI" content online is a framework tutorial wearing a trend costume. Install LangGraph, copy a config, watch an agent call a tool, ship a LinkedIn post. Andrew Ng's new course on DeepLearning.AI takes the opposite approach: no framework until you understand what the framework is hiding from you.
Agentic AI, taught personally by Ng, is free, runs about six hours self-paced, and ends with a certificate. The only hard prerequisite is intermediate Python. Basic familiarity with LLMs and APIs helps, but the course doesn't assume you've already built an agent.
The core bet: patterns before frameworks
Ng builds every agentic design pattern in raw Python first, then shows how the same idea maps onto popular frameworks. That ordering matters more than it sounds. If you learn LangChain's AgentExecutor before you understand what it's actually doing, you inherit its abstractions, its defaults, and its bugs without knowing why any of them exist. Learn the pattern in fifteen lines of plain Python, and the framework becomes optional syntax sugar instead of a black box.
The course covers four design patterns:
- Reflection — the model critiques its own output and revises it, functioning like automated code review.
- Tool use — the LLM decides which functions to call: web search, database queries, calendar access, code execution.
- Planning — breaking a complex task into ordered sub-tasks the agent can execute and adapt as conditions change.
- Multi-agent collaboration — coordinating multiple specialized agents on one task, the way a company splits work across employees with different roles.
Evals get more attention than most courses give them
The most useful part of the syllabus isn't the four patterns. It's the emphasis on evaluation and error analysis, which Ng treats as the actual skill gap between people who ship working agents and people who spend months tuning prompts and stall out.
Teams that don't know how to run a disciplined eval and error-analysis process can spend months tweaking agents with little to show for it.
That's a real problem, not a theoretical one. An agent that calls a search tool, summarizes results, and writes a report can fail in a dozen silent ways: bad retrieval, hallucinated synthesis, a broken handoff between planning and execution. Without traces and evals at each step, you're debugging by vibes. The course builds this in as a running thread rather than a bolt-on final module.
What you actually build
The course's capstone example is a deep research agent: it plans a research strategy, calls a web search engine, pulls relevant pages, synthesizes and ranks findings, drafts an outline, edits for consistency, and generates a Markdown report. That's a legitimate multi-step agentic workflow, not a toy demo, and it's the kind of thing teams are actually shipping right now for research assistants, legal document review, and customer support triage.
| Detail | Value |
|---|---|
| Instructor | Andrew Ng |
| Platform | DeepLearning.AI |
| Cost | Free |
| Length | ~6 hours, self-paced |
| Prerequisite | Intermediate Python; basic LLM/API knowledge helps |
| Certificate | Yes |
| Language taught in | Pure Python, vendor-neutral (frameworks covered after fundamentals) |
Who should actually take this
If you've already shipped an agent with LangGraph or CrewAI and it works, you might not need this. If you've tried to ship one and it broke in ways you couldn't diagnose, this course is aimed directly at you. It's also a good fit for developers who want to skip the framework-of-the-month cycle entirely and understand what's underneath all of them.
Beginners with shaky Python will struggle. This isn't an introduction to programming with AI sprinkled on top; it assumes you can read and write real code without hand-holding.
The trade-off worth naming
Building everything in raw Python first is the course's biggest strength and its biggest time cost. You won't walk out with a production LangChain app in six hours. You'll walk out understanding why LangChain's agent executor makes the choices it makes, which pays off the first time something breaks in production and the framework's error message is useless.
Takeaway: if your goal is to actually debug agents instead of just deploying them, understanding the raw mechanics first is worth the extra hour or two over a framework-first tutorial.