The Awakening: When Software Learned to Want Things

The Awakening: When Software Learned to Want Things

The cursor blinked on Maya Chen's empty editor like a metronome counting down to something she couldn't name. It was 9:47 a.m. on a Monday in March, her fourth day at Lumen Systems, and her first real assignment sat in a single line of JIRA ticket text:

> *Build an agent that can handle inbound customer refund requests.*

She stared at the word. *Agent.* She'd heard it at the all-hands. She'd read the blog posts. She'd nodded along in standups when people said things like "we're going agentic" and "the agent will own that workflow." But now, with a blank PyCharm window staring back at her, the word dissolved into vapor. What, exactly, was she supposed to build?

Maya was not a beginner. She had six years of backend experience, two years building data pipelines at a fintech, and a deep familiarity with REST APIs, message queues, and the kind of deterministic systems where every input produced a predictable output. She knew how to write a `for` loop that called a third-party API. She knew how to model a state machine. What she did not know—had never been taught, because no one had been taught—was how to write software that *wanted things*.

She closed her laptop, walked three cubicles down, and knocked on the frame of her mentor Devon's open office. Devon had been at Lumen for nine years. He'd built the original search ranking system. He'd survived two rewrites and one acquisition. He was, by every measure, the kind of engineer who knew not just how systems worked, but why they had to be built a certain way.

"Hey," Maya said. "I need you to define something for me."

Devon looked up from a thermal paste tube he was inexplicably applying to a Raspberry Pi. "Define what?"

"An agent."

He set the tube down, swiveled his chair, and gave her the look she would come to recognize over the next three months: the look of a man deciding whether to give her the textbook answer or the true one.

"Sit down," he said. "This is going to take a while."

---

The Question That Started Everything

The problem Maya faced is not unique to her. It is the central problem of an entire generation of software engineers suddenly asked to build systems whose behavior is governed, at least in part, by a large language model. The vocabulary has raced ahead of the understanding. Every product manager wants "an agent." Every investor wants "agentic AI." Every conference talk uses the word as if its meaning were obvious. It is not.

So let us begin where Maya began, with the honest admission that the term is fuzzy at the edges, and work our way toward the precise definition that will govern the rest of this book.

The word *agent* comes from the Latin *agere*, meaning *to do* or *to act*. In philosophy, an agent is anything that *acts*—that has the capacity to bring about change in the world. A stone rolling down a hill is not an agent, because its motion is fully explained by forces acting on it. A bacterium swimming toward sugar *is* an agent, in a minimal sense, because it senses its environment, makes something resembling a decision, and moves with purpose.

In artificial intelligence, the term has been used for decades to describe systems that exhibit this property of goal-directed action. The classical AI textbook definition, refined over half a century of research, has four moving parts:

1. Perception — the ability to sense or observe the state of an environment. 2. Reasoning — the ability to interpret those observations and decide what they imply. 3. Action — the ability to do something that changes the state of the environment. 4. Goal-directedness — the property of having an objective that the system is, in some meaningful sense, *trying* to achieve.

If a system has these four properties, it is, by convention, an agent. A chess program is an agent. A self-driving car is an agent. A thermostat is, in the loosest possible sense, an agent. What makes the present moment historically unusual is that a new class of systems—*large language model agents*, or *LLM agents*—has emerged that satisfies these properties using a foundation model as the reasoning engine.

Here is where the precision becomes important. An LLM agent is not the same thing as a chatbot. A chatbot produces text in response to text. It has no goals, no tools, no memory across turns, no ability to act on the world. You can use it to write a poem, summarize a document, or explain a concept. It cannot book your flight, file your expense report, or recover a stuck database, because it does not *do* anything. It speaks.

An LLM agent *does*.

It perceives its environment by reading the contents of a conversation, the output of a tool call, the result of a database query, or the state of a file system. It reasons about those perceptions using a foundation model whose parameters encode something resembling common sense, world knowledge, and instruction-following. It acts by emitting structured outputs—function calls, shell commands, API requests—that external systems execute. And it persists across this loop, accumulating a memory of what it has tried, what has worked, and what has failed.

The key word is *loop*. A chatbot is a one-shot function: input in, output out. An agent is a closed feedback system: the output of one cycle becomes the input of the next, and the cycle continues until some termination condition is met. This loop is the conceptual atom from which every agent you will ever build is composed. Master it, and you master the field. Ignore it, and you will build systems that fail in the same predictable ways that every naive prototype fails.

But we are getting ahead of ourselves. Before we can understand the loop, we need to understand where it came from.

---

A Brief History of Wanting Things

The idea that a machine could *want* things is older than electronic computing. In 1950, Alan Turing, in his paper *Computing Machinery and Intelligence*, proposed the famous imitation game and considered, almost in passing, whether a machine could be said to have intentions. He concluded that the question was not well-posed—that we attribute intentions to other humans on the basis of their behavior, and we might one day do the same for machines. He was right, but the practical demonstration of that idea took another two decades.

The first true AI agents were built in the late 1960s and early 1970s, and the one that matters most for our story is called SHRDLU. Built by Terry Winograd at MIT between 1968 and 1970, SHRDLU was a natural-language interface to a simulated robot arm operating in a small world of colored blocks. You could type things like *"Pick up the big red block and put it in the box,"* and SHRDLU would parse the instruction, plan the sequence of arm movements, execute them, and respond in English with a description of what it had done.

SHRDLU is the ancestor of every agent you will ever build. It had perception (the state of the block world), reasoning (a parser and a planner), action (commands to the simulated arm), and goal-directedness (the user's instruction). It was, by any reasonable definition, an agent.

What SHRDLU did *not* have was generality. It worked only in its tiny world of blocks. The moment you stepped outside that world, its understanding evaporated. This was the central failure mode of classical AI: agents were brittle. They could reason brilliantly within their domain and collapse the moment the domain shifted. Researchers spent forty years trying to solve this brittleness, and most of them failed. The field fractured into subdisciplines—expert systems, planning, reinforcement learning, knowledge representation—each attacking the problem from a different angle, none of them producing the general-purpose reasoning system that the founders had promised.

Then, in 2017, a small team at Google Brain published a paper with an unassuming title: *Attention Is All You Need*. It introduced the tra