One tool call was Lesson 9. This lesson asks what happens when one isn't enough — when a model has to decide, act, observe, and decide again, on its own, until a goal is actually met. Four real properties, one 1995 standard, and what turns a single loop into a team.
Lesson 9 showed a model asking for one tool, once, for one question. Lesson 10 showed it reaching into a whole shelf of them. This lesson asks the obvious next question: what happens if one tool call isn't enough?
Real tasks rarely take one step. Booking a meeting room means checking a calendar, then checking room availability, then sending a confirmation — three separate tool calls, each one depending on what the last one found. Nothing about the mechanism changes. It just doesn't stop after one.
An agent is what you get when that mechanism repeats on its own: decide what to do, do it, look at what happened, decide the next thing — around and around, however many times it takes, until the goal is actually met. Nobody clicks send again between steps. The model's own output decides whether there's a next step at all.
That's the whole definition. Not a bigger model, not a different kind of intelligence — the exact same next-token machine from Lesson 1, given a goal instead of a single question, and allowed to keep pulling the same lever until it's done.
This is the first of a few properties worth naming precisely — real terms, from an actual academic standard for what counts as an agent, not marketing language. Autonomy means the system decides its own steps and knows when it's done, without a human approving each individual move.
You didn't tell it to check the calendar first, then the room, then send the email. You said "book a room for Thursday." It worked out the order.
Reactivity means it actually looks at what its last action produced before deciding what's next — not following a fixed script written in advance.
If the first room it checks is booked, a reactive agent doesn't fail. It reads that result — right there in the context, exactly like Lesson 8's backpack — and tries the next room instead. The plan isn't fixed at the start. It's built one step at a time, out of what actually happened.
Everything in this course so far has assumed a person types something first. Pro-activeness breaks that assumption: the system can start on its own, from a schedule or an event, instead of waiting to be prompted.
A check that runs every morning at 8am. A workflow that wakes up the moment an email arrives. Neither one needed a person to type anything at all — the trigger was time, or the world doing something, not a message.
The last property is the one that turns a single loop into a team. Social ability means agents can talk to other agents — and to people — not just to tools.
One agent researches, hands its findings to a second agent that writes, which hands a draft to a third that reviews it. Each one is still just the same loop from a moment ago — decide, act, observe, repeat — except sometimes what it "observes" is another agent's output, and sometimes what it "acts" on is asking a person a question it genuinely can't answer alone.
Autonomy, reactivity, pro-activeness, social ability — these four properties were named in 1995, decades before anyone said "AI agent" out loud, by researchers defining what any intelligent agent needs, software or otherwise. Most systems that call themselves agents today only really clear two of the four.
Curious how a platform built specifically to clear all four actually works? See the full agent standard.
Everything up to this point could only tell you something. An agent can actually do something — send an email, move money, change a record. That raises the stakes on the very last question this course set out to answer.
Everything from the lessons before this one, plus what this lesson added.
| The board | The word for it |
|---|---|
| The board and its pegs | The structure — the model |
| A single peg | A neuron |
| A single step from one peg to the next | A connection |
| How red or blue a patch of floor is | A weight — a parameter |
| The whole painted floor | The trained model |
| Boards stacked, one on the next | Layers — "deep" |
| Smearing the floor in, coin by coin | Training |
| Dropping one coin through a finished board | Using it — inference |
| Which slot you pour into | Your input — your prompt |
| The bins, relabelled with tokens | The vocabulary — every token it could pick |
| The tallest pile among the bins | The prediction — the likeliest next token |
| Feeding the growing line back in and running again | The loop — how one guess becomes a sentence |
| One bin's label, precisely | A token — not always a whole word |
| How many bins there are, in total | Vocabulary size — tens of thousands |
| The size of the mountain of text it was shown | Training data — measured in tokens |
| A bin's own address, plotted in space | An embedding — meaning turned into a list of numbers |
| How close two addresses sit | Similarity — how related two things are |
| The measurement's real name, out in the wild | Cosine similarity — same idea as similarity, different name |
| About meaning, not exact spelling | Semantic |
| A neighbourhood of addresses that share a topic | A domain — a cluster of related meaning |
| Scanning every address for whichever one sits closest to a new point | Nearest neighbor — the closest real match to a computed point |
| A small, separate machine that only plots words as points — it never writes a sentence | An embedding model — not the same as a language model |
| The total number of coloured patches, across every board | Parameters — the number people quote |
| How many tokens the funnel can hold in one pour | Input tokens — the context window |
| How many tokens come back out | Output tokens — what it writes back |
| Everything you've met so far, built at real-world size | A Large Language Model — an LLM |
| A shorter pile winning, extended forward with full confidence | A hallucination |
| The point where the training reading stopped | The knowledge cutoff |
| How sharp or blended the colour stays before a coin is poured | Temperature — the dial on how often a stray pick wins |
| Pouring the same slot twice, not always the same pile | Non-deterministic — same input, no guaranteed identical output |
| Background, examples, or a role, added right into the pour | Context |
| Asking for many small steps instead of one big leap | Chain-of-thought prompting |
| A friendly chat window built around the board | A product — like ChatGPT or Claude.ai |
| A door that lets software pour in and read out directly | An API |
| What each million tokens costs to send in or get back | API pricing — pricier for bigger models, and for output |
| Recalling the start of the line instead of re-pouring it | Cached tokens — priced far cheaper than fresh input |
| The board asking the app to go do something real before it answers | Tool use — or function calling |
| One shared shape for listing tools and calling them | MCP — Model Context Protocol |
| A program that speaks that shape and hands back its whole toolbox | An MCP server |
| + New in this lesson | |
| The loop deciding, acting, and watching what happened, on repeat | An agent — a model with tools, looping until the goal is met |
| Deciding its own steps, and knowing when it's done | Autonomy |
| Reading what just happened before deciding what's next | Reactivity |
| Starting on its own, from a schedule or an event | Pro-activeness |
| Talking to other agents, and to people, not just tools | Social ability |
44 rows now. It keeps growing as the course goes on.