Sign in to continue learning
Agentic AI
Intermediate
2 hours 45 mins
Topics
Agents
Agents can be autonomous to different degrees. A few years ago, I noticed within the AI community that there was a growing controversial debate about what is an agent, and some people are writing a paper saying I built an agent, and others will say, no, that's not really a true agent. And I felt this debate was unnecessary, which is why I started using the term agentic, because I thought if we use it as an adjective rather than a binary, it's either an agent or not, then we're going to have to acknowledge that systems can be agentic to different degrees. And let's just call it all agentic and move on with the real work of building these systems rather than debating, you know, is this sufficiently autonomous to be an agent or not? I remember when I prepared a talk on agentic reasoning, one of my team members actually came to me and said, hey, Andrew, we don't need yet another word. You know, we have agent, why are you making up another word, agentic? But I decided to use it anyway. And then later on, wrote an article in a given newsletter, The Batch, and then also posted on social media, saying that instead of arguing over which word to include or exclude as being a true agent, let's acknowledge that different degrees to which systems can be agentic. And I think this helped move past the debate on what is a true agent and let us just focus on actually building them. Some agents can be less autonomous. So take the example of writing an essay about black holes. You can have a relatively simple agent to come up with a few web search terms or web search queries. Then you can hard code in that you call a web search engine, fetch some web pages, and then use that to write an essay. And this is an example of a less autonomous agent with a fully deterministic sequence of steps. And this will work okay. In terms of notational convention, throughout this course, I'll use the red color, as you see here on the left, to denote the user input, such as a user query in this case, or in later examples, maybe the input document into an agentic workflow. The gray boxes denote calls to an LLM, and the green boxes, like the web search and the web fetch boxes that you see here, indicate steps where other software is being used to carry out an action, such as a web search API call or executing code to fetch the contents of a website. Then an agent can be more autonomous, where, given a request to write an essay about black holes, perhaps you let the LLM decide, does it want to do a web search, or does it want to search recent news sources, or does it want to search for recent research papers on the website archive? Based on that, maybe in this example, the LLM, not the human engineer, but the LLM chooses, in this case, to call a web search engine, and then after that, you may let the LLM decide how many web pages does it want to fetch, or if it fetches the PDF, does it need to call a function, or also call a tool, to convert the PDF to text? And in this case, maybe it fetches its top few web pages, then it can write an essay, decide whether to reflect and improve, and maybe even go back to fetch more web pages, and then to finally produce an output. And so even for this example of a research agent, we can see that some agents can be less autonomous, with a linear sequence of steps to be executed, determined by a programmer, and some can be more autonomous, where you trust the LLM to make more decisions, and the exact sequence of steps that happens may be even determined by the LLM, rather than in advance by the programmer. So for less autonomous systems, you will usually have all the steps predetermined in advance, and any functions it calls, like web search, and we'll call that tool use, as you learn in the third module in this course, might be hard-coded by the human engineer, by you or me, and most of the autonomy is in what text the LLM generates. At the end of the spectrum would be highly autonomous agents, where the agent makes many decisions autonomously, including, for example, deciding what is the sequence of steps it will carry out in order to write the essay. And there's some highly autonomous agents that can even write new functions, or sometimes create new tools that it can then execute. And somewhere in between are semi-autonomous agents, where it can make some decisions, choose tools, but the tools are usually more predefined. As you look at different examples in this course, you learn how to build applications anywhere on this spectrum of less to more highly autonomous, and you find that there are tons of applications in the less autonomous end of the spectrum that are very valuable being built for tons of businesses today, and at the same time, there are also applications being worked on at the more highly autonomous end of the spectrum, but those are usually less easily controllable, a little bit more unpredictable, and also a lot of active research as well to figure out how to build these more highly autonomous agents. And with that, let's go on to the next video to dive deeper into this and to hear about some of the benefits of using agents and why they allow us to do things that just were not possible with earlier generations of base applications.
Module 1: Introduction to Agentic Workflows