吳恩達 Agentic AI 第五講 Agentic AI applications

• URL: https://www.youtube.com/watch?v=KDaqamIFtgI
• Channel: 扣子說AI
• Fetched: 2026-08-12T17:49:52+00:00
• Language: English (auto-generated)

Transcript

[00:02] Let’s take a look at some examples of
[00:04] agentic AI applications. One task that
[00:07] many businesses carry out is invoice
[00:10] processing. So, given an invoice like
[00:13] this, you might want to write software
[00:15] to extract the most important fields,
[00:17] which for this application, let’s say is
[00:19] the biller, that would be TechFlow
[00:21] Solutions, the biller address, the
[00:23] amount due, which is $3,000, and the due
[00:26] date, which looks like it is August
[00:28] 20th, 2025. So, in many finance
[00:31] departments, maybe a human would look at
[00:34] invoices and identify the most important
[00:36] fields, who do we need to pay, by when,
[00:38] and record these in a database to make
[00:41] sure the payment is issued in time. If
[00:43] you were to implement this with an
[00:45] agentic workflow, you might do so like
[00:48] this. You might input an invoice, then
[00:50] call a PDF-to-text conversion API to
[00:53] turn the PDF into maybe formatted text
[00:56] such as markdown text for the LM to
[00:58] ingest. Then, the LM will look at the
[01:00] PDF and figure out, is this actually an
[01:02] invoice, or is this a some other type of
[01:05] document that I should just ignore? And
[01:06] if it is an invoice, then it will pull
[01:09] up the required fields, as well as use
[01:12] an API or use a tool to update the
[01:14] database in order to save the most
[01:16] important fields in the database
[01:18] records. So, one aspect of this agentic
[01:21] workflow is that there is a clear
[01:23] process to follow. It’s identify the
[01:26] required fields and record in the
[01:27] database. Tasks like these with a clear
[01:29] process if one followed tend to be maybe
[01:32] easier for agentic workflows to carry
[01:34] out, because it leads to a relatively
[01:36] step-by-step way to reliably carry out
[01:39] this task. Here’s another example, maybe
[01:41] just a little bit harder. So, if you
[01:43] want to build agents to respond to basic
[01:46] customer order inquiries, then the steps
[01:48] might be to extract the key information,
[01:51] so figure out what exactly did the
[01:53] customer order, what was the customer’s
[01:54] name, then look up the relevant customer
[01:56] record, and then finally draft a
[01:59] response for human to review before the
[02:02] email response is sent to the customer.
[02:05] So, again, there’s a clear process here,
[02:06] and we will implement this step-by-step
[02:08] where we take the email, feed it to an
[02:10] LLM to verify or to extract the order
[02:13] details. Assuming the customer email is
[02:16] about an order, the LLM might then
[02:18] choose to call an orders database to
[02:20] then pull out that information. That
[02:22] information then goes to the LLM to
[02:25] draft an email response. And the LLM
[02:27] might choose to use a request review
[02:29] tool that say puts this draft email from
[02:32] the LLM into queue for humans to review
[02:35] so they can then be sent out after a
[02:36] human has reviewed and approved it. So,
[02:39] customer order inquiry agents like these
[02:41] are being built and deployed in many
[02:43] businesses today. To look at a more
[02:45] challenging example, if you want to
[02:47] build a customer service agent to
[02:49] respond not just to questions about an
[02:51] order they placed, but to respond to
[02:53] more general set of questions, anything
[02:56] a customer may ask. And maybe customer
[02:59] will ask, “Do you have any black jeans
[03:01] or blue jeans?” And to answer this
[03:03] question, you need to maybe make
[03:06] multiple API calls to your database to
[03:08] first check the inventory for black
[03:10] jeans, then check inventory for blue
[03:11] jeans, and then respond to the customer.
[03:13] So, this is an example of a more
[03:15] challenging query where given a user
[03:17] input, you actually have to plan out
[03:19] what is the sequence of database queries
[03:21] to check for inventory. Or if a user
[03:24] asks, “I’d like to return the beach
[03:25] towel I bought.” Then to answer this,
[03:28] maybe we need to verify the customer
[03:31] actually bought a beach towel, and then
[03:33] double-check the return policy. Maybe it
[03:34] says returns only 30 days within the
[03:36] date of purchase, and only if the towel
[03:38] is unused. And if return is allowed,
[03:41] then have the agent issue a return
[03:43] packing slip, and also set the database
[03:46] record to return pending. So, in this
[03:48] example, if the required steps to
[03:50] process a customer request are not known
[03:52] ahead of time, then it results in a more
[03:55] challenging process where the LM-based
[03:57] application has to decide for itself
[04:00] that these are the three steps needed in
[04:02] order to respond appropriately to this
[04:05] task. But, you learn about some of the
[04:07] latest work on how to approach this type
[04:10] of problem, too. And to give one last
[04:11] example, maybe an especially difficult
[04:14] type of agent to build, there’s a lot of
[04:16] work on computer use by agents. And we
[04:19] say agents will attempt to use a web
[04:21] browser and read a web page to figure
[04:23] out how to carry out a complex task. In
[04:26] this example, I’ve asked an agent to
[04:29] check where the seats are available on
[04:31] two specific United Airlines flights
[04:33] from San Francisco to Washington, D.C.
[04:35] or the DCA airport. The agent has access
[04:38] to a web browser they can use to carry
[04:41] out this task. And in the video here,
[04:42] you can see it navigating the United
[04:44] website independently, clicking on page
[04:46] elements, and filling in the text fields
[04:48] on the page to carry out the search that
[04:50] I requested. As it works, the agent
[04:53] reasons over the content of the page to
[04:55] figure out the actions it needs to take
[04:57] to complete the task and what it should
[04:59] do next. In this case, there’s some
[05:00] trouble checking flights on the United
[05:02] site, and instead decides to navigate to
[05:05] the Google Flights website to search for
[05:07] available flights. On the Google Flight,
[05:10] you see here it finds several flight
[05:11] options that match the user’s query. And
[05:14] the agent then picks one and is taken
[05:17] back to United website where it looks
[05:19] like it’s now on the correct web page
[05:21] and so is able to determine that yes,
[05:24] there are seats available on the flights
[05:26] that I asked about. So, computer use is
[05:28] an exciting, cutting-edge area of
[05:30] research right now, and many companies
[05:32] are trying to get computer use agents to
[05:34] work. While the agent you saw here did
[05:36] eventually figure out the answer, I
[05:38] often see agents having trouble using
[05:40] web browsers well. For example, if a web
[05:42] page is slow to load, an agent may fail
[05:44] to understand what’s going on, and many
[05:46] web pages are still beyond agent’s
[05:48] abilities to parse or to read
[05:50] accurately. But, I think computer use
[05:52] agents, even though not yet reliable
[05:55] enough to use in mission-critical
[05:56] applications today, are a exciting and
[05:59] important area of future development.
[06:00] So, when I’m considering building
[06:03] agentic AI workflows, the tasks that are
[06:06] easier will tend to be ones where there
[06:08] is a clearer step-by-step process, or if
[06:11] a business already has a set of
[06:12] procedure, a set of operating procedures
[06:14] to follow. And then, it can be quite a
[06:16] lot of work to take that procedure and
[06:18] codify it up in an AI agent, but that
[06:21] tends to lead to easier implementations.
[06:23] One thing that makes it easier is if
[06:25] you’re using text-only assets, because
[06:28] LLMs, large language models, have grown
[06:30] up really processing text. And if you
[06:32] needed to process other input
[06:34] modalities, it may well be doable, but
[06:36] it maybe gets a little bit harder. And
[06:38] on the harder end of the spectrum, if
[06:39] the steps are not known ahead of time of
[06:42] what’s needed to carry the task, like
[06:43] you saw for the more advanced customer
[06:45] service agent, then the agent may need
[06:47] to plan or solve as you go, and this
[06:49] tends to be harder and more
[06:50] unpredictable and less reliable. And
[06:52] then, as mentioned, if it needs to
[06:54] accept rich multimodal inputs, such as
[06:56] sound, vision, audio, that also tends to
[06:59] be less reliable than if only had to
[07:01] process text. So, I hope that gives you
[07:04] a sense of the types of applications you
[07:06] might build with agentic workflows.
[07:09] When implementing one of these things
[07:11] yourself, one of the most important
[07:12] skills is to look at a complex workflow
[07:15] and figure out what are the individual
[07:17] steps so they can implement an agentic
[07:19] workflow to execute those steps one at a
[07:22] time.
[07:23] In the next video, we’ll talk about task
[07:25] decomposition. That is, given a complex
[07:28] thing you want to do, like write a
[07:30] research report or have a customer agent
[07:32] get back to customers, how do you break
[07:35] that down into discrete steps to try to
[07:37] implement an agentic workflow?
[07:39] Let’s go see that in the next video.