The Building Blocks of an Agent

Many modern LLM-based agents can be understood through four common building blocks: a model, tools, some form of state or memory, and instructions or goals. Not every agent needs all four in the same form, but this framework is a useful way to understand most of the systems you’ll encounter.

1. The model (the brain)

This is the LLM from Lesson 1: Claude, GPT, Gemini, or an open-weight model like Meta’s Llama or Alibaba’s Qwen. The model reads the current situation and decides what should happen next. It doesn’t execute anything itself. It predicts, and in an agent, part of what it predicts is which action to take.

An agent doesn’t have to run on one model end to end. A cheap, fast model might handle simple classification steps, while a more capable model handles the hard reasoning. Mixing model sizes within one system is becoming common as agent builders try to control cost. A 2026 industry writeup on the shift from single models to full agentic systems documents it directly: teams increasingly reach for smaller, cheaper models for structured decision-making instead of routing everything through one large general-purpose model (Kapini, Medium, 2026).

2. Tools (the hands)

A model on its own can’t check today’s weather, search a database, or send a Slack message. Tools are the bridge. A tool is simply a defined function the agent is allowed to call: search the web, read this file, run this calculation, send this email. When the model decides it needs current information or needs to perform an action, it outputs a structured request to use a specific tool, and the surrounding software runs it, then hands the result back to the model.

This mechanism has a formal name, function calling or tool calling. It’s the single most important technical idea in this whole series, enough that Lesson 5 is dedicated to it entirely.

3. Memory (the notes)

A raw LLM has no memory between separate conversations. Memory in an agent is a way of storing information outside the model so it can be pulled back in later: what a user prefers, what happened three steps ago in a long task, facts learned earlier in a project. Memory ranges from something as simple as a running log injected back into the prompt, to more elaborate systems that store and search past interactions.

Without some way of maintaining state, long or multi-step tasks become much harder to manage, because the agent can lose track of what it has already tried, what it learned, or what remains to be done. That’s part of why “human-in-the-loop” design, checkpoints where a person reviews progress, has become common practice rather than a nice-to-have. A 2026 piece on agentic AI makes the same argument: the most reliable systems are the ones that know when to pause and ask, not the most autonomous ones (Kapini, Medium, 2026).

4. Instructions (the goal)

This is the system prompt or task definition, the text that tells the agent what it’s supposed to accomplish, what boundaries it should respect, and often what tone or format to use. Good instructions are specific about the goal and the constraints: “research three competitors and summarize pricing, don’t make purchases, flag anything uncertain,” rather than vague, “help with research.”

Instructions are also where a lot of real-world safety work happens. Telling an agent what it’s not allowed to do is often more important than telling it what it should do.

How the four fit together

Picture a common agent loop: instructions or goals set the objective, the model (brain) decides a next step, a tool (hands) may carry it out, and the resulting state becomes part of what the model can use next. Repeat until the goal is met, a limit is reached, or the agent hands off to a human. Not every agent uses all of these pieces in exactly this way.

That loop is the actual mechanism behind “agentic AI,” and it’s the subject of Lesson 4.

Carry into Lesson 04

• Model, tools, memory, instructions: every agent is some combination of these four things.
• Tools are one of the main things that let an agent move beyond generating text and interact with the outside world. In modern LLM-based agents, tool access is often what turns a model’s decision into an observable action.
• Memory and clear instructions are what keep a multi-step agent from going off the rails.

Next lesson, we watch these four pieces work together in the actual decision loop that makes an agent “agentic.”