Andrew Ng's 2025 New Course: Core Methodology and Best Practices for Building AI Agents

Course Background: The Hype and Real Value of Agentic AI

Andrew Ng has launched a brand-new course, AI Agents, on the Deeplearning.AI platform, offering a systematic guide to building Agentic AI applications powered by large language models. At the start of the course, Ng candidly shares an amusing observation: when he first coined the term "agentic" to describe an important trend in AI application development, he never anticipated that marketers would latch onto it so aggressively — slapping the label on nearly every product imaginable — causing hype around Agentic AI to skyrocket.

The good news, however, is that beyond the hype, the number of genuinely valuable and useful Agentic AI applications is also growing rapidly — just not quite as fast as the buzz. The core goal of this course is to teach best practices for building Agentic AI applications and help developers unlock entirely new possibilities.

The Origins of Agentic AI

The concept of Agentic AI is rooted in the long-standing "agent" theory within AI research. As far back as the 1990s, Stuart Russell and Peter Norvig defined an Agent in their seminal textbook Artificial Intelligence: A Modern Approach as "an entity that perceives its environment and takes actions to maximize the achievement of its goals." But it wasn't until large language models (LLMs) demonstrated powerful reasoning and tool-calling capabilities that Agentic AI transitioned from an academic concept into an engineering practice. From late 2023 into early 2024, the explosion of open-source projects like AutoGPT and BabyAGI rapidly brought "Agentic" into mainstream discourse — and with it, the technology entered the classic "Peak of Inflated Expectations" on the Gartner Hype Cycle. The hype Ng observed is a textbook manifestation of this cycle: a flood of products simply wrapped the "Agent" label around traditional features without genuinely implementing autonomous planning or multi-step execution.

Real-World Applications of Agentic Workflows

In the course, Ng highlights several domains where Agentic workflows are already being widely deployed:

• Customer Support Agents: Building AI agents capable of autonomously handling customer inquiries, dramatically improving service efficiency
• Deep Research: Helping produce in-depth, insight-driven research reports through intensive information synthesis and analysis
• Legal Document Processing: Handling complex legal documents, extracting key information, and performing compliance analysis
• Medical Diagnostic Assistance: Suggesting possible diagnostic directions based on patient-provided information

The Fundamental Difference Between Agentic Workflows and Traditional LLM Calls

Understanding why these use cases require Agentic workflows comes down to recognizing how they fundamentally differ from traditional LLM calls. Conventional LLM applications typically follow a "single-call" pattern: the user submits a prompt, the model returns a result, and the interaction ends. Agentic workflows, by contrast, introduce loops, branching logic, and autonomous decision-making — an Agent can plan task steps, invoke external tools (such as search engines, databases, or APIs), inspect intermediate results, revise its strategy based on feedback, and maintain contextual state across multiple steps. This workflow essentially elevates the LLM from a "question-answering tool" to a "coordinator for executing complex tasks." Common implementation frameworks include LangChain's Agent module, LlamaIndex's Agent abstraction, and OpenAI's Function Calling mechanism. It is precisely this multi-step, stateful, tool-enabled execution model that makes the complex applications described above possible.

These use cases share a common thread: they all involve complex multi-step reasoning, information synthesis, and decision-making — far beyond what a simple, single LLM call can accomplish. Ng emphasizes that across the many teams he has led, a large number of projects simply would not have been possible without Agentic workflows. This underscores just how critical it is to master Agent development.

Core Competency: A Disciplined Development Process

One of the most noteworthy insights in the course is Ng's sharp observation about the gap between expert developers and average ones. He argues that the biggest difference between those who excel at building Agentic workflows and those who struggle is not familiarity with model APIs or prompt engineering skills — it's the ability to drive a disciplined development process, with a particular focus on Evals (Evaluation) and Error Analysis.

Why Are Evals and Error Analysis So Critical?

Agent systems differ fundamentally from traditional software development. Traditional software behaves deterministically, whereas an Agent's behavior is highly non-deterministic — the same input can produce different execution paths and outputs. This means:

1. You cannot assess system quality from a single test run: A systematic evaluation framework is needed to measure Agent performance across a wide range of scenarios.
2. Error patterns are complex and varied: An Agent can fail at any point in its reasoning chain, requiring fine-grained error analysis to pinpoint the root cause.
3. Iterative optimization must be data-driven: Without quantitative evaluation metrics, optimization is reduced to guesswork, making it highly inefficient.

The Unique Challenges of Evaluating Agent Systems

In traditional machine learning, evaluation typically relies on fixed test sets and well-defined metrics such as accuracy or F1 score. Agent systems, however, face unique evaluation challenges. First, an Agent's output is often open-ended — a single task may have multiple valid execution paths and several acceptable final outcomes, making it difficult to predefine a "correct answer." Second, Agent behavior is stochastic, influenced by factors like the model's temperature parameter and real-time variations in tool outputs, meaning multiple runs on the same input can yield dramatically different results.

Commonly used evaluation methods in the industry include: LLM-as-Judge (using another large model to assess the Agent's output quality), human annotation scoring, trajectory-based process evaluation (assessing not just the final result but also the quality of intermediate reasoning steps), and benchmark suites targeting specific capability dimensions. Companies like OpenAI and Anthropic have built large-scale internal Evals infrastructure to support Agent product iteration — OpenAI's open-source Evals framework, for example, provides a standardized evaluation pipeline.

A Systematic Methodology for Error Analysis

Error analysis for Agent systems is far more complex than debugging traditional software. A failed Agent task can stem from multiple sources: poorly designed prompts causing model misinterpretation, incorrect tool-call parameters, logical leaps in intermediate reasoning steps, information loss due to context window overflow, or miscommunication between multiple agents.

A systematic error analysis methodology typically includes: categorizing and labeling failure cases (e.g., "tool call error," "broken reasoning chain," "hallucinated output"), tracing the full execution trajectory to identify the first point of failure, analyzing the frequency distribution of error types to prioritize improvements, and building regression test sets to ensure fixes don't introduce new problems. This methodology draws on root cause analysis (RCA) and continuous integration principles from traditional software engineering, adapted for the non-deterministic nature of AI systems. Observability tools like LangSmith and Arize Phoenix are specifically designed to support this workflow.

This emphasis on methodology is what sets this course apart from the many Agent tutorials on the market that stop at "call an API + write a prompt" — it genuinely addresses the core engineering challenges of deploying intelligent agents in production.

Course Value and Learning Recommendations

Ng makes it clear that mastering the ability to build Agentic AI is one of the most important and valuable skills in the AI field today. Whether you're pursuing career opportunities or looking to independently build outstanding software products, this skill will open up a wealth of new possibilities.

For developers who want to go deep on Agent development, it's worth focusing on the following areas:

• Understand Agentic workflow design patterns: Including core paradigms such as ReAct, Plan-and-Execute, and Multi-Agent collaboration. ReAct (Reasoning + Acting), proposed by Yao et al. in 2022, is an Agent paradigm whose core idea is to have the model alternate between "thinking" (generating a reasoning chain) and "acting" (calling tools or executing operations) at each step, deciding the next move based on observations. The Plan-and-Execute paradigm splits tasks into two phases: a "planner" model first generates a complete task decomposition plan, then an "executor" carries out each subtask step by step, with the planner dynamically adjusting the plan based on execution feedback. Multi-Agent collaboration involves multiple agents with different roles and capabilities working together — for example, one agent handles information retrieval, another handles code writing, and a third handles quality review — completing complex tasks through role specialization and information passing. These paradigms are not mutually exclusive and are often combined in real-world engineering.
• Establish an evaluation framework from the very start of a project: Design evaluation metrics and test cases early to provide data support for subsequent iterations.
• Prioritize a systematic approach to error analysis: Learn to extract improvement directions from failure cases and build a closed-loop optimization cycle.
• Learn through practice: Build Agents in the context of real business scenarios rather than staying at the theoretical level.

The course comes with slides and code, providing an excellent starting point for hands-on practice. In an era of rapid AI Agent evolution, systematically mastering these methodologies will be the key to establishing a competitive edge in the field of intelligent agent development.

Key Takeaways

• Andrew Ng's new course systematically covers AI Agent development, emphasizing real value over hype
• Agentic workflows are already widely used in customer support, deep research, legal document processing, and medical diagnostics
• The biggest gap between expert and average developers lies in a disciplined development process — especially Evals and Error Analysis
• Mastering Agentic AI development is one of the most important skills in AI today, opening up significant career and entrepreneurial opportunities