Andrew Ng's Agentic AI course teaches four design patterns, but its best lesson is evals

On the HumanEval benchmark, GPT-4 scores 67.0% zero-shot. GPT-3.5, a weaker model, reaches 95.1% when wrapped in an agent loop. Andrew Ng cited these figures in The Batch on 20 March 2024 to argue that how you organise work around a model can matter as much as the model.

That post introduced four design patterns, and they now have a full course of their own: Agentic AI on DeepLearning.AI. The course’s long title lists all four: reflection, tool use, planning and multi-agent workflows. Most learners will sign up for them.

If you are aiming for an FDE role, though, the most valuable part of the course is not in its title.

Who teaches it, and who is it for?

Andrew Ng is the founder of DeepLearning.AI and a co-founder of Coursera. He teaches this course himself, and it is rated intermediate. The official page gives no launch date. It shows only a last update of 31 August 2026, and Coursera also marks the course as updated in September 2026.

The prerequisites are intermediate Python, so you can follow the implementations, and a basic understanding of LLMs and how to call their APIs. Coursera divides the course into 5 modules and estimates 2 weeks at 10 hours a week.

If you have two to eight years of experience and have called an LLM API before, the foundations will give you no trouble.

The course defines agentic AI as a new way of building software in which an LLM completes some or all of the steps of a complex task. The word “some” matters. Not every system needs a fully autonomous agent, and the course saves the highly autonomous patterns for its last module.

Four patterns, ordered by autonomy

Across the 5 modules, the four patterns and the eval material run from Module 2 to Module 5. Module 2 teaches reflection, which Ng defines as an LLM examining its own output to find ways to improve it. Module 3 moves to tool use, including MCP and code execution.

Module 5 groups the remaining two patterns under the heading “Patterns for Highly Autonomous Agents”: planning, in which the LLM devises and executes a multi-step plan to reach a goal, and multi-agent systems.

Each pattern comes with specific labs. The Customer Service Agent lab covers planning, the Market Research Team lab covers multi-agent systems, and a further lesson covers communication patterns between agents.

If you want to work as an FDE, put the most effort into the customer service lab. The agent has clear inputs and outputs, so it is easy to measure with the techniques from Module 4.

The teaching method is what sets the course apart. Every pattern is built in Python from first principles, without any framework. For an FDE this is a real advantage. At a customer site you rarely get to choose the stack, and when a framework misbehaves, only someone who understands the underlying loop can debug it.

Why Module 4 is the skill that pays

Module 4 sits between tool use and the highly autonomous patterns, and its content is quite different from the rest of the course. It teaches evals, error analysis, component-level evaluation, and measuring latency and cost. One lesson covers analysing errors and then deciding which next step to take first.

This is the part closest to FDE work. Imagine you have deployed a customer service agent for a bank and it gets 15% of questions wrong. At that point, knowing one more pattern does not help much.

You need to know whether the errors come from retrieval, tool calls or planning, which fix will give the biggest gain, and how each fix changes latency and cost. The simplest approach is to take a sample of failed runs and assign each one to the component that caused it.

The table below is a hypothetical example covering 20 failed runs from that banking agent.

Component	Example error (hypothetical)	Count / 20
Retrieval	Pulled last year’s fee schedule	9
Tool calls	Passed an account number in the wrong format to the lookup API	7
Planning	Skipped identity verification before answering	4

Reading this table, retrieval is the step to fix first, because it accounts for nearly half the errors. Adding a reflection loop across the whole agent may look more appealing, but it adds latency and cost even to the steps that already work.

Ng’s 95.1% figure should be read the same way. An agent loop can lift a weak model above a strong one, but you only know the loop is helping if you can measure it. Without evals, it is hard to tell whether reflection or planning is doing anything for your system.

What order should you study in?

Before you enrol, read the 2024 post in The Batch to see what problems the four patterns were meant to solve. Then follow the course in its own order, starting with reflection and tool use before the highly autonomous patterns. Agents get more steps towards the end of the course, and more steps make them harder to debug.

Give Module 4 more time than Coursera estimates, and apply its techniques to the agents you built in Modules 2 and 3.

When you add the course to your CV, do not just list the certificate. Turn the Customer Service Agent lab into a GitHub project with an error analysis table like the one above: how many runs, which component each error came from, what you fixed first and why.

Writing the code from first principles, as the course teaches, also shows employers that you can take these patterns to any stack.

When reading an FDE job description, look for “evaluation”, “error analysis” or “latency and cost”. A project with an error analysis table speaks directly to those requirements.

The four patterns will keep changing with each generation of models. The habit of measuring before fixing will stay useful, whichever model wins the next benchmark.