A Practical Guide, Part 1 of 15: What Makes Something an Agent

Co-host: Which is overdue, because right now I'm pretty sure my toaster has an agent strategy.

Host: Your toaster probably has a pitch deck. So, the series. Over fifteen parts we go from what makes software an agent, through designing and running agentic systems, all the way to making them reliable and aligned. We start at intermediate level and build to advanced.

Co-host: And why follow along? Because if you buy, build or manage these tools, the word agent is doing a lot of hiding. Knowing what's under it saves you money and embarrassment.

Host: Here's the working definition we'll test all episode. An agent is a model that pursues a goal by choosing its own actions, using tools, and reacting to what comes back. Three ingredients: a goal, tools, and a loop.

Co-host: Quick term first. When we say model, we mean a large language model, software trained on huge amounts of text, its training data, to predict what words come next.

Host: Picture the old way. You ask a chatbot what the weather is in Lisbon, and it confidently guesses from memory. It can talk, but it can't go and look.

Co-host: Right, it's a very well read person locked in a room with no window.

Host: The researcher Lilian Weng gave an influential picture of the alternative. The language model acts as the agent's brain, and around it sit three supporting parts: planning, memory and tool use.

Co-host: Let me translate those. Planning is breaking a goal into steps. Memory is what it can keep track of, starting with the context window, which is just how much text the model can see at once. Tool use is calling out to things like search or a calculator.

Host: And underneath sits a pattern from a research paper called ReAct. The idea is that the model writes out its reasoning and takes actions, alternating between the two rather than doing all its thinking up front.

Co-host: And the actions are the window in the locked room. The paper's point is that actions let the model reach outside sources, like a knowledge base or an environment, and pull in information it didn't have.

Host: So think, act, see what happened, think again. Steelman the skeptic for a second: isn't that just a chatbot with extra steps?

Co-host: Honestly, mechanically, sort of. Same model. The difference is who decides the next step. In the loop, the model reads the result and picks what to do next. That's the shift.

Host: So in practice, when someone sells you an agent, ask whether it can look things up and act, and whether it changes course based on what it finds. If not, it's a chatbot in a nicer coat.

Host: Now imagine you're comparing three vendor brochures. Each uses agent differently, or seems to. Look closer and they mostly line up.

Co-host: Anthropic draws the cleanest line. Workflows are where the model and tools follow code paths a developer laid out in advance. Agents are where the model steers its own process and its own tool use.

Host: They go further: in an agent, the model keeps control over how it gets the task done, deciding dynamically rather than following a script.

Co-host: OpenAI's take is more of an engineer's parts list. In their Agents SDK documentation, an agent is a language model set up with instructions, tools, and some optional runtime behavior.

Host: And Google Cloud offers a ladder. A bot automates simple tasks or conversations. An assistant helps users with tasks. An agent performs tasks autonomously and proactively.

Co-host: And the key rung, for Google, is who decides. With an assistant, the user makes the decisions. Agents sit at the top with the most autonomy.

Host: So where's the tension? OpenAI's definition is about ingredients, Anthropic's and Google's are about who holds the wheel. You can have the ingredients and still run them as a fixed script.

Co-host: Which is fine, by the way. Plenty of great products are workflows wearing an agent badge for marketing.

Host: The practical test, then: ask who decides the next step, the developer's code or the model. That one question sorts most of the brochures on your desk.

Host: Let's walk through a concrete one. A developer types into a coding agent like Claude Code: fix the failing tests. What happens next?

Co-host: I'll narrate this as a general pattern, not a spec for any one product. First, the harness. That's the software wrapped around the model that gives it tools, like reading files, running commands, editing code, and feeds the results back.

Host: So the model is the brain, the harness is the hands and eyes.

Co-host: Exactly. Step one, the model reasons: I should see which tests fail. It asks the harness to run the test suite. Step two, the output comes back, say a couple of failures with error messages. Step three, it reasons again, opens the relevant file, spots a likely bug.

Host: Then it edits?

Co-host: Then it edits, reruns the tests, and reads the result. If something else breaks, it goes round again. It stops when the tests pass or it decides it needs to ask you. Goal, tools, loop. All three ingredients in one errand.

Host: And each step exists for a reason. Running tests gives it ground truth instead of guesses. Rerunning checks its own work. The loop is what lets it recover from its first wrong idea.

Co-host: Where it fails: it can misread an error, chase the wrong file, or, my favourite, make the test pass by changing the test. Very efficient, completely wrong.

Host: The student who fixes their grade by editing the answer key. So for you: an agent's power comes from its tools, and so do its risks. Know what it can touch, and check what it did, not just what it says it did.

Host: Final scene. A support team, a pile of tickets, and someone in a meeting saying, let's make it agentic.

Co-host: Support and coding are the classic places agents earn their keep, because the tasks are open ended but the results can be checked, did the ticket get resolved, do the tests pass.

Host: But autonomy isn't free. Anthropic warns that agentic systems often swap extra latency and cost for better results on the task, and it advises finding the simplest solution that works.

Co-host: Latency meaning waiting time. Every loop is another model call, and each call costs money and seconds. Ten laps round the loop is ten bills.

Host: So the ladder runs: a single good prompt, then a fixed workflow, and only then a true agent, when the path genuinely can't be known in advance.

Co-host: From building these: start simple, measure, and earn your way up. The agent should be the answer to a problem, not the answer looking for one.

Host: In practice, before saying yes to agentic, ask whether the steps are predictable. If they are, a workflow is cheaper, faster and easier to trust.

Host: The takeaway: an agent is defined by who decides the next step. A goal, tools, and a loop where the model reads the results and chooses again. Everything else is a chatbot, a script or an assistant, and those are often the better choice.

Host: This was part of our series Agentic AI: A Practical Guide. The show notes list every source, and this episode was made with AI voices, which is, admittedly, AI explaining AI. Follow AI Shadow for the rest of the series. Goodbye for now.