Agentic AI Applications: What Tasks Is Agentic AI Suited To?
Notes on the applications lecture: invoices, order inquiries, open-ended customer service and computer use, and what makes one task harder than another.
Notes on the Agentic AI applications lecture in Module 1 of Andrew Ng’s Agentic AI course (DeepLearning.AI). This is my personal study notebook; it is not affiliated with or endorsed by the course or its authors. Paraphrases of the lecture are marked From the lecture. Everything else is my own working.
Agentic AI — Module 1: Agentic AI applications
Same technology, very different difficulty
Reading an invoice and booking a flight through a website can both be done with an agentic workflow. One is something businesses rely on today. The other still fails when a page loads slowly. What makes the difference?
This lecture walks through four applications, from easier to harder, and ends with a way of telling them apart. That is the part I want to be able to use: a quick judgement, before building anything, of how hard a task will be.
Four applications, from easier to harder
Each tab is one example from the lecture, drawn in the course’s colour convention. Use “Who decides?” to see how the share of decisions made by the AI grows as the examples get harder.
1 · Invoices
Extract the fields a finance team needs (biller, biller address, amount due, due date) and record them so payment is made on time.
- Invoice arrives (User input; person decides) — A PDF, for example from Tech Flow Solutions: $3,000 due on 20 August 2025.
- Convert PDF to text (Software / tool; developer decided) — A PDF-to-text API produces formatted text, such as Markdown, for the LLM.
- Is this actually an invoice? (LLM call; developer decided) — If not, the document is ignored.
- Extract the required fields (LLM call; developer decided) — Biller, biller address, amount due, due date.
- Update the database (Software / tool; developer decided) — Save the fields through an API, so payment can be scheduled.
2 · Order inquiries
Answer a customer’s question about an order they placed. Still a clear process, with a person approving the reply.
- Customer email (User input; person decides) — A question about an order.
- Extract the order details (LLM call; developer decided) — What was ordered, and the customer’s name.
- Look up the order (Software / tool; AI decides) — The LLM may choose to call the orders database.
- Draft a reply (LLM call; developer decided)
- Queue for review (Software / tool; AI decides) — The LLM may choose a request-review tool, which places the draft in a queue.
- Person approves (Human review; person decides) — Only then is the email sent.
3 · Open-ended service
Answer anything a customer asks. The steps depend on the question, so the application has to work them out each time.
- Customer request (User input; person decides) — “I’d like to return the beach towel I bought.”
- Plan the steps needed (LLM call; AI decides) — Nothing in the code says which checks a return needs.
- Verify the purchase (Software / tool; AI decides) — Did this customer actually buy a beach towel?
- Check the return policy (Software / tool; AI decides) — For example: within 30 days of purchase, and unused.
- Issue a return packing slip (Software / tool; AI decides) — Only if the return is allowed.
- Set the record to “return pending” (Software / tool; AI decides)
4 · Computer use
Use a web browser to complete a task, reading each page and deciding what to do next.
- Request (User input; person decides) — Check whether seats are available on two specific United flights from San Francisco to Washington DCA.
- Read the page, decide the next action (LLM call; AI decides) — Reasons over what is on screen. Repeats after every action
- Click and type in the browser (Software / tool; AI decides) — Navigates the airline site, fills in fields.
- Change approach when stuck (Software / tool; AI decides) — In the lecture’s demo, it switched to Google Flights, then returned to the airline site.
- Answer (Output; AI decides) — Yes, seats are available.
Two things change from tab to tab. The process becomes less fixed: by the third example the code no longer says which steps to take. And the input becomes richer: the fourth reads web pages built for human eyes.
From the lectureAndrew Ng notes that agents for basic customer order inquiries are being built and deployed in many businesses today.
For the open-ended questions, such as “do you have black jeans or blue jeans?”, the application has to plan its own sequence of database queries, for example checking the inventory for each colour before answering.
Computer use: impressive, not yet dependable
The fourth example is the most striking to watch, and the lecture is careful not to oversell it.
From the lectureIn the demo, the agent eventually confirms that seats are available, after trouble on the airline’s site and a detour through Google Flights.
Andrew Ng observes that agents often have trouble using web browsers: a slow-loading page can confuse them, and many pages are still beyond their ability to read accurately. He describes computer use as an exciting and important area of research that is not yet reliable enough for mission-critical applications.
I find this a useful counterweight to the hype from Lecture 01. The demo succeeds, but succeeding once is different from succeeding every time. An engineer has to ask about the failure rate, not only the best run.
What makes a task easier or harder?
The lecture closes with a summary along one axis, which I have redrawn here:
Easier
The process can be written down in advance.
- Clear, step-by-step process
- Standard procedures to follow
- Text assets only
Harder
The process has to be worked out while doing it.
- Steps not known ahead of time
- Plan / solve as you go
- Multimodal inputs (sound, vision)
From the lectureTasks with a clear process, or where a business already has a standard procedure, tend to be easier. Turning that procedure into an AI workflow can still be a lot of work, but it tends to lead to easier implementations.
Text-only inputs make it easier too, because language models have mostly been trained on text. Other modalities may be doable but tend to be harder. Tasks where the steps are not known ahead of time, so the agent must plan as it goes, tend to be harder, less predictable and less reliable.
Putting this beside Lecture 03 makes the pattern clear to me: difficulty grows with the number of decisions the model has to make at run time. A standard procedure means the developer made those decisions in advance. Unknown steps mean the model must make them, and every decision is another chance to be wrong.
Engineering reflection: reading the axis as a design tool
My own summary of the four examples against the lecture’s criteria:
Example | Process known in advance? | Who plans the steps | Input |
|---|---|---|---|
Invoices | Yes | Developer | Text (after conversion) |
Order inquiries | Yes | Developer, with small model choices | Text |
Open-ended service | No | Model | Text |
Computer use | No | Model, after every action | Web pages (visual) |
Three practical habits I am taking from this:
Look for the procedure first. If the business already has a written process, start there. That is the easy end of the axis, and much of the value.
Convert to text early. The invoice workflow turns a PDF into text before the model sees it, which moves the task towards the easier end.
Split hard tasks. A hard request often contains easy parts. A return request still has a fixed check (the 30-day policy) that ordinary code can do reliably.
Pause and thinkWhere would you place each of these on the axis, and why? (1) Summarising today’s delivery temperature records. (2) Reading photographed, handwritten delivery notes. (3) Investigating why one depot keeps breaching its temperature limit.
My current answer
1 is near the easy end: a fixed procedure over text and numbers, much like the invoice example.
2 is harder because of the input: the steps are clear, but reading handwriting from photos is a vision task, which tends to be less reliable than text.
3 is harder because of the process: nobody knows the investigation’s steps in advance, so the system would have to plan as it goes, like the open-ended customer service example.
What I learned
Agentic workflows are already useful for tasks with a clear process, such as invoice processing and order inquiries with human review.
Difficulty rises when the steps are not known ahead of time and the system must plan as it goes.
Multimodal inputs, such as images, sound and web pages, tend to be less reliable than text.
Computer-use agents are a promising research area, but not yet reliable enough for mission-critical work.
Many hard tasks contain easier parts; finding them is a design skill.
My engineering takeawayBefore choosing a model or a framework, place the task on the axis. Is the process known? Is the input text? The answers predict much of the difficulty.
The lecture ends by naming the skill that connects all of this: looking at a complex task and working out its individual steps. That is task decomposition, and it is the subject of the next lecture.