Why AI Agents Don't Really Automate Much of Anything: Your Shortcut to Managing a Machine

Hello! Today we're going to talk about AI agents. It's a topic everyone seems to want to discuss. I've spent a lot of time over the last couple of months just getting my head around things. I have really summarized it down to this.

AI agents don't really automate much of anything. They essentially can't be left on their own to do whatever they want. Instead, they serve as a shortcut to management. Specifically, this means you will spend a lot of time managing a machine rather than managing people or other aspects of your work. So, AI agents are likely here to stay, and there has been a lot of interesting discussion about what AI agents can do and their purpose. I will outline a few perspectives on how you might think about an agent and what an agent might mean for you.

When you start thinking about an agent, you may consider automation as a first step, right? You might think, okay, we're going to have some sort of trigger for the agent. We'll send the data from that trigger to the AI model, and then we'll receive a result back. This could be integrated into a Zapier tool or some other kind of automated workflow.

And this kind of gives you a little bit of magic, right? You could think, "Okay, interesting. I'm able to use this to create an agent that interprets my emails, for example, or an agent that performs some basic tasks for me that are helpful." That’s one way you might consider an agent. It's a very basic view, and I think the people who talk about agentic systems would probably dismiss this perspective.

A bit further down, we have the capable bot, which is effectively a very similar tool—something that you're interacting with more regularly. There's a conversation happening, potentially. You ask it a question, and the bot replies to you with a response. Along the way, it may use a tool, data, or some sort of capability to provide that response in a more meaningful way. Additionally, it could even perform an action on your behalf, which is fairly interesting.

It could also set up an action to be performed, right? It could present you with a button that you could click to execute an action as well. That's a nice technique for using bots. Again, this relates to the concept of what you might think an agent is. I believe that agentic people out there might be thinking we are getting closer, but not quite there yet.

Okay, let's take this a step further. You might start getting into task completion, let’s call it, and chain of thought. With this, you are now giving a general task for the LLM to figure out. It breaks that task down into some steps and calls on some of its AI LLMs to perform those tasks for you. For example, if I say I'm going to plan a birthday party, the LLM might respond, "Cool! What should we buy?"

Who should we invite and how? What should the schedule for Party B be, for instance? These might be the three different steps that get created. Then, the LLMs go off and complete those steps, bringing together the outcomes. This AI LLM can then integrate those results into a holistic conclusion. The significance of this AI LLM at the end is important because, along the way, each of these tasks may have been executed in a manner that doesn't adequately represent the entirety of the solution. There may be context from some of the other steps that was overlooked.

We may apply, and where the party is in one of the steps, that should actually inform the kind of gifts or activities that we do, right? So you might need this aim to roll with the punches and combine things in a unique way. This is still very much a work in progress. It's getting there; it's getting closer. However, I think the agentic folks would still look at this and say, "Hmm, I don't see a loop."

I don't see any way for this thing to learn or develop its own evaluations of how close it is. So, that's what we get into when we talk about agents, in a way. There are two levels to this, but let's discuss the agent piece first. Agents are similar to the tools we had earlier; they're kind of like an AI that knows how to do something. They have the capability to perform certain tasks, and that's essentially what an agent is. It’s capable of resolving issues based on the tools it has at its disposal, as well as some context or data. You could break this down into steps, too. For instance, you might have a consultant agent that knows all the different venues in town and can help you find one. Then, you could have another agent that specializes in shopping, and yet another one that has expertise in a different area. You might also have an organizer or planner agent that brings everything together. This starts to become "agentic" when you consider these different agents performing various tasks. However, when people truly think about agentic systems, they're usually envisioning a scenario where you have a task given to a manager. That task is then broken down into a series of steps, which are performed by agents. The manager can understand the results as they come from these steps—one at a time, not all at once—and can address problems as they arise, resolving issues in real time. You can see this with some of the integrated development environments (IDEs) that have emerged, like WindSurf. You can also observe it with some of the models from OpenAI, such as the 01 model. These models are increasingly being designed to navigate challenges more effectively, accommodating changes as they occur.

And that's interesting and unique, right? There's a very cool capability there, especially when the agents are able to understand the context of where they're working. But again, what are the core problems with this? When I think about building systems with LLMs, the biggest thing I consider is accuracy. I often use a highly accurate model to solve problems because I'm trying to address somewhat general issues, not ones that a specific model has been trained on.

And I'm usually not interested in training a model because I'm thinking about it from a product perspective. So I often look at accuracy as a kind of nice measure. These measures, of course, come from the scale of mathematical evaluation, but I just use them as a general example. There are a ton of leaderboards, and I'm not specifically privy to this one, but I found it kind of interesting as a measure here. So, you know, these models are somewhat accurate.

Let's say it's around 95% accurate. As we begin to take that accuracy, we run it through a series of steps. We start with our complex question and run it through a language model (LLM). This LLM has been shown to be approximately 95% accurate, so it provides a relatively accurate result.

If the step relies on the result from the first one, then accuracy compounds. For example, if the first model has an accuracy of 95%, then the next model, which relies on the output of the first, can only achieve an accuracy of 90.25%. Similarly, each subsequent step experiences a decline in accuracy: the step following that can only be 85.7% accurate. As we start compounding these inaccuracies into a complex result, accuracy drops significantly. Initially, at the first step, we are 95% accurate, but by the fifth step, we are down to 77.4% accuracy. By the tenth step, accuracy falls to 59%, and by the twentieth step, it drops to just 35.08%. Consequently, as we develop these agentic systems, their ability to understand the problem space and adapt swiftly to ongoing issues becomes increasingly challenging.

These AI large language models (LLMs) do not handle the output of other LLMs very well. Therefore, we need to ground them in the truth of the world. This is generally why, when we have AIs coding for us, they will look at the actual output of the program to ground themselves in reality, rather than relying solely on what the previous AI generated. They will examine the real results of the examples, which significantly helps increase accuracy. This approach allows us to connect the AI's output to reality. The problem, however, is that what we often end up grounding our AI on are the errors we observe, the UI visuals, and perhaps some aspects of the functionality. What we unfortunately do not effectively ground it on is our mission or objective. This is challenging because we typically provide the AI with a complex question at the beginning. As it progresses through each step, it struggles to reassess its alignment with the mission objective and determine whether it is getting closer to or further from that goal, unless the objective is measurable.

Unless it's something that we can create a test against or run something against, there's no way to tell how much closer we are. As a result, the AI goes off on a cascade of increasingly inaccurate results. I experienced this firsthand when I ran some code using Windsurf. I watched the same issue unfold; I let it run with the solution, and it eventually crashed on itself multiple times. I kept trying to poke or prod it, attempting to guide it toward what I thought was the right solution, but it really couldn't fully grasp even the broad context I provided, which was just about setting up an app with Tailwind inside a monorepo. The nuance of the monorepo simply didn't come through. Even as I continued the conversation and provided more prompts, it lost the thread and the mission—the objective that I initially gave it, which was what I wanted it to hold on to. This is such a complex issue as well.

So it's difficult to hold on to, which kind of leads me to this general belief that agents are generally less accurate than regular models. When we let these agents solve problems for us, autocomplete our text, or automate certain processes that we want them to handle without our intervention, we often find that their outcomes are less reliable. If we give them the entire problem to solve without checking their work or having them ask us questions along the way, they tend to be less accurate. However, this also indicates that agents excel at certain tasks. They are particularly good at providing creative solutions where accuracy isn't critical. For instance, one could argue that creating an AI-generated podcast is not a task where accuracy is of utmost importance.

Notebook LLM's ability to tell you about something is not necessarily about telling it to you very accurately; it's about presenting it in a fun way. You could use Notebook LLM to produce propaganda fairly easily, creating feelings of positivity or excitement about a solution that, in reality, may not be very relevant. The accuracy of what it represents doesn't come into play. They are also skilled at taking a few short steps that don't drop off quickly. If these agents can form a series of very short steps, that can be beneficial as well. Again, while we probably shouldn't be overly critical, we can improve if we just keep the steps short.

And then additionally, there are problems that don't rely on prior thinking, right? If you need to target several different tasks and you can assign an agent to each of those tasks, your accuracy doesn't drop significantly because each task is separate. They don't rely on each other. Again, it just kind of feels like at that point, why are you setting all the agents up together?

Why not just have different tasks or automations run? That's the question I always come back to whenever I'm trying to set up a system. I think, okay, maybe agents could work here. However, I start to realize that it’s hard enough to build a solution around an LLM's output as it is—just as a chain of automation. Allowing it free reign to problem-solve within that space without a human to guide it becomes tricky. This leads me to my final point. The thing that agents are best at is human-in-the-loop tasks, and that’s where we see agents deployed most effectively. These are tasks where a human helps the agent along, and both work side by side to solve problems. Peter Thiel discusses this concept extensively in "Zero to One," emphasizing that computers and humans work best together when they enable each other. I believe agents perform very well in that collaborative space. This is why tools like Windsurf, Cursor, and other AI agentic tools work effectively for programmers. Programmers are specialists who possess knowledge in their field, and those tools can enhance their expertise.

They do not replace that specialty, you know. They can't task that agent to do something on their behalf. They need to stay within the loop, checking it along the way and validating that what it’s doing makes sense. Sometimes, I’ve found that this can get boring. Occasionally, you end up managing the machine and doing the task rather than just doing it yourself.

And so that's where you need to find that judgment of, okay, I've got this agentic system. It's really interesting, it's really cool, and it's very powerful. But how do I factor into this now? In general, I think OpenAI and a lot of the enthusiasts around AI tools have really kind of jumped the gun on agents.

I don't think we were really ready yet. I believe that until we can achieve 99% accuracy on a lot of tasks, agents are more of a nice, cool feature, but they are not yet fully practical. I'm just not sure when we’re going to get there. I don't know when that accuracy will reach a 99% threshold where I would be okay with running 10 steps and still being less accurate than what we have now. So that's sort of where things stand for me on this. Since today is just heading into the holidays, I thought I'd leave you with a little demo of something that I've been working on for a while. This is a little monster creator I developed around Halloween with some friends. We just put it together as a fun way to create D&D monsters. When the new Monster Manual comes out, we will definitely revamp this a bit.

But what you can do is create a prompt for generating a monster. So, I'm going to create a scary version of Santa. Great! I've designed Santa riding a skeletal horse, haunting Christmas, and flying on a shadow sleigh. There's something interesting here, so we’re going to summon that monster. This process involves a series of tasks, and I have incorporated elements to ensure that it refers to and double-checks the monster it creates to better fit the rule set. I treat this as a separate piece, where creativity and fun come together in the monster's design. This approach is somewhat similar to how the Notebook LM team operates, which inspired my method. As you can see, all of the abilities and traits undergo a final pass, adding a bit of fun and creativity to the output. This monster creator agent generates not only the monster but also an image that represents it, and then brings everything back for us to review. Now, we can observe it going through the various steps. I haven't run it for a while, so I think the server was a bit cold upon initiation, but you can see it generated the stats, critiqued them, and added some creative flair. Now, it’s building out a nice image for us to look at. And there we go! This is our Santa on the shadow sleigh. You can see him riding his phantom horse; he’s classified as a medium undead. The creation includes a good number of spells and abilities he might have, such as "Yuletide Terror," "Twilight Assault," and "Shadow Staff." He even has some legendary actions. So, there is our monster, completely created by an agent.

Well, thank you so much for tuning in. Happy holidays! I hope everyone is having a warm and safe holiday season. I also hope you're getting a chance to play with some AI. If you're interested in learning more about AI or what we're up to, we have our blog over on Stable Discussion, where, for instance, we provided an overall review of Windsurf and included a link to the video there as well.

I would love it if you could subscribe, like the video, and also check out our subscription at blog.stablediscussion.com, where you can find us. Thank you so much, and we'll catch you in the next one in the new year!