What is an AI Agent?

This is the framing post for AI agents, and the goal is to install one crisp distinction: a chatbot answers, an agent acts. Most people meet LLMs through a chat box and assume that's the ceiling of what they can do. The agent idea breaks that ceiling by wrapping the same model in a loop where it can take real actions.

The cover headline says 'beyond the chatbot' deliberately, because the entire mental shift is realizing the model is no longer the whole system — it's the reasoning core of a larger system that includes tools, memory, and a control loop.

An AI agent is best defined by what it adds to a plain LLM: a loop and the ability to act. You give it a goal rather than a single question. It reasons about what to do, takes an action through a tool, observes the result, and repeats until the goal is satisfied.

The key word is 'until.' A chatbot does one turn and stops. An agent keeps going, using feedback from each action to decide the next one. That feedback loop is what lets it complete tasks rather than just describe them, and it's the property every other slide in this post elaborates.

This comparison is the heart of the concept, so it gets its own slide. On the left, a plain LLM call is stateless and worldless: it takes text in, returns text out, can't check its own work, and forgets everything between calls. On the right, an agent pursues a goal across many steps, acts on the world through tools, observes outcomes, and carries memory forward.

The practical reading is that an agent is not a smarter model — it's the same model embedded in a scaffolding that gives it persistence, feedback, and reach. You can turn almost any capable LLM into an agent without retraining it.

Naming the four parts gives the reader a durable schema for everything that follows. The model is the brain that plans and decides. Tools are the functions it can call to actually do things. Memory is whatever state persists across steps — at minimum the running conversation. The loop is the control flow that ties them together: think, act, observe, repeat.

This four-part breakdown is worth memorizing because every agent framework, no matter how complex, is ultimately some arrangement of these four pieces. When you read about planners, executors, or memory stores later, you can map them straight back to this list.

The mindmap diagram lays the four parts around a center so the reader sees them as facets of one system rather than a pipeline. The model plans and reasons; tools cover searching, running code, and hitting APIs; memory holds context, a scratchpad, and history; the loop drives act-observe-repeat.

Seeing them radiate from 'AI Agent' reinforces that no single piece is the agent. Strip out the tools and you have a chatbot. Strip out the loop and you have a one-shot tool call. The agent is the combination, and the diagram makes that combination concrete.

Agency is a loaded word, so this slide pins down what it means in practice: the model chooses which action to take next, rather than you hard-coding the sequence. You supply a goal and a toolbox; the model decides how to combine the tools to reach the goal.

The important nuance is that this autonomy is bounded. An agent can only do what its tools permit — it has no powers you didn't grant. That framing matters both for understanding capability and for safety: you control the ceiling of what the agent can do by choosing which tools to expose.

This slide states the loop in plain language before the next post formalizes it. Read the goal and current state, decide whether you can answer now or need a tool, call the tool if needed, feed the result back, and repeat until the goal is met. It's a simple while-loop with a smart decision at its center.

The reason to spell it out in words first is that the loop is genuinely the whole trick. Newcomers often imagine something far more mysterious. Showing that an agent is a bounded loop with the LLM making the branch decision removes the magic and makes building one feel approachable.

This first code slide is intentionally schematic, not runnable, because the point is the shape, not the API. A goal seeds the state; while the goal isn't done, the model decides an action; if that action is a tool call, you run it and append the result; otherwise the model has produced a final answer and you break.

The pseudocode maps one-to-one onto the four parts: model.decide is the brain, run_tool is the hands, appending to state is the memory, and the while is the loop. Post 4 turns this exact skeleton into real, runnable code against a real model.

This slide makes the role of tools concrete, because tools are what separate an agent from a chatbot. By itself an LLM can only produce text — it can't check a database or send an email. A tool is a function you register so the model can request that something happen in the world.

The division of labor matters: the model picks the tool and the arguments, but your code executes it and returns the result. The model never directly touches your systems; it only emits a structured request. That boundary is both how tools work mechanically and where you enforce safety.

The mental-model slide compresses the post into rules to keep. An agent is a brain plus hands plus a loop. Its job is to pursue a goal, not answer once. It decides the steps while you grant the powers by choosing its tools. And crucially, more autonomy means more capability but also more risk.

That last point is the bridge to the rest of the series. Everything powerful about agents — choosing their own steps, acting on the world — is also everything that can go wrong, which is exactly what the 'why it matters' and 'mistakes' posts unpack.

The CTA closes the concept post and points to motivation. We've established the core distinction (act vs answer), the four parts, what agency means, and the loop in plain words.

Day 76's teaser asks the obvious follow-up: if an agent is just an LLM in a loop, why is that such a big deal? Post 2 answers by showing what acting unlocks that pure answering never could — and where that power is and isn't worth the added complexity and risk.