Hello, Agent World: What Even Is an Agent?

Hello, Agent World: What Even Is an Agent?

The Word "Agent" Is Doing Too Much Work

I want you to do a quick experiment. Open your phone, your email, your browser tabs—wherever you've talked to another human recently—and search for the word "agent." You'll find:

• A real estate agent who shows you apartments
• An FBI agent who... well, you know
• A travel agent who books flights
• A cleaning agent you spray on counters
• A literary agent who pitches your novel
• A customer service "agent" who pops up in a chat window asking if you need help

Six different meanings, all fighting for the same word. By the time you finish this chapter, you'll have a seventh meaning to add to your collection, and it might be the most useful one: a software agent, the kind of program that quietly powers your spam filter, recommends your next Netflix show, drafts emails for you, and—at the high end—holds a conversation that feels weirdly human.

The goal of this chapter isn't to drown you in jargon or send you hunting for academic papers. It's to give you a clear, jargon-free picture of what people mean when they say "agent" in the world of software, and to set up the bigger question this entire book is built around: what happens when you put a bunch of these agents together?

Let's start with the smallest possible idea and build up from there.

A quick note before we go further: the word "agent" has been bouncing around in computer science since the 1970s, but it really broke into the mainstream around 2023, when large language models became powerful enough to actually do useful work. Before that, "agent" was a slightly stuffy academic word that mostly lived in research papers. After that, it became the word every tech company wanted to slap on its product. So when you see "agent" used today, half the time it means something specific and useful, and half the time it's marketing fluff. By the end of this chapter, you'll be able to tell the difference.

The Tiniest Definition That Still Works

Strip away everything—the buzzwords, the academic papers, the breathless LinkedIn posts—and you're left with this:

An agent is something that perceives its environment and acts on it.

That's it. That's the whole definition at its core.

The word "something" is doing a lot of heavy lifting, because it can mean many things:

• A robot vacuum that perceives the dirt on your floor and acts by driving over it
• A thermostat that perceives the room temperature and acts by turning the heat on or off
• A spam filter that perceives the contents of an incoming email and acts by routing it to your junk folder
• A chess program that perceives the current board state and acts by moving a piece
• A large language model that perceives your typed question and acts by generating a reply

All of these are agents. They're wildly different in sophistication, but they share the same skeleton.

Notice what's *not* in the definition. It doesn't say the agent has to be smart. It doesn't say it has to use AI, or neural networks, or anything fancy. A dumb old-fashioned program that checks the weather once an hour and emails you a reminder is technically an agent. So is a Roomba that bumps into your couch and turns left. The key is the loop: perceive → decide → act → perceive again.

This loop is so important that it's worth seeing it as a picture.

```mermaid flowchart LR A[Perceive Environment] --> B[Decide What to Do] B --> C[Act on Environment] C --> A ```

Read that diagram clockwise. The agent looks at the world, makes a decision, does something, and then the world has changed—so it looks at the world again. Forever. As long as it's running, this loop keeps spinning.

Most ordinary programs don't quite work this way. A normal program typically takes some input, runs a fixed procedure, and produces an output. Then it stops. A calculator waits for you to type "5 + 3," does the math, and shows "8." Done. It's not really *acting on an environment*—it's just answering a question you put in front of it.

An agent, by contrast, is always running. It doesn't wait for you to ask. It's continuously perceiving the world around it, and it has the authority to take action on its own.

That last bit is important, and it's the difference between a program and an agent in a nutshell. Programs are *reactive tools*—they wait for you. Agents are *active workers*—they go out and do things.

There's another subtle thing in the diagram worth noticing: the arrow from "Act on Environment" loops back to "Perceive Environment." This isn't a stylistic choice. It's the whole point. The agent's actions change the world, and the next perception reflects those changes. If a chess agent moves a pawn, the next time it looks at the board, that pawn is in a different square. If a trading agent buys a stock, the next time it looks at the market, the price may have moved. The loop isn't just procedural—it's *causal*. Actions shape what gets perceived next.

This is what makes agents different from any other kind of software. A spreadsheet doesn't change the world. A web browser doesn't change the world. An agent *does*.

What Makes Something a "Real" Agent? The Four Big Traits

The definition above is the bare minimum. To call something a *true* agent in the academic and engineering sense, researchers usually look for four traits. I'll call them by their initials—ARPS—which doesn't officially stand for anything, but it's easy to remember because it sounds like the burping sound a robot might make after eating too much electricity.

1. Autonomy

An autonomous agent makes its own decisions without a human (or another program) telling it exactly what to do at every step.

Think about your dishwasher. You load it, you press the button, it runs. It's not really an agent—it's just an appliance following a script. Even though it has sensors and motors, every step of what it does is predetermined by the manufacturer.

Now think about a self-driving car. It perceives traffic lights, pedestrians, the car in front of it, the weather. It decides when to brake, when to turn, when to honk. Nobody is sitting in the back seat saying "okay, now check the left mirror, now accelerate by 2.3 mph." The car is *autonomous*—it makes those decisions itself.

In software, an autonomous agent might:

• Decide which of several tools to call to answer your question
• Choose when to send you a notification versus when to stay quiet
• Pick the order in which to tackle a list of tasks
• Decide it needs more information before acting
• Adjust its strategy when the first attempt fails

A program that follows a strict flowchart isn't autonomous, even if it's useful. An agent has at least some wiggle room in how it behaves.

Autonomy comes in degrees, by the way. A Roomba is partly autonomous (it decides its own path) but partly scripted (it always returns to the dock when the battery is low). A Tesla in Autopilot is mostly autonomous but still requires a human to take over in tricky situations. A Waymo robotaxi is fully autonomous in its operating domain. These are all autonomous, but they differ in how much decision-making power they actually have.

2. Reactivity

A reactive agent notices when its environment changes and responds in a timely way.

This sounds obvious until you realize how often it's missing from everyday software. Most programs are "blind"—they don't notice the world until you poke them. Your word processor doesn't care that you've typed a typo until *you* press spell-check. Your bank's website doesn't notice your balance has dropped until *you* log in.

A reactive agent is different. It keeps its eyes open. A real-time trading bot watches stock prices tick by and reacts the moment something unusual happens. A network monitoring agent notices that a server's CPU is at 100% and raises an alarm before things melt down. A security camera agent notices motion in the yard and starts recording.

The key word is