%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#E8ECFF", "primaryBorderColor": "#4054B2", "primaryTextColor": "#16171B", "lineColor": "#3B4351", "edgeLabelBackground": "#FAF7F0", "clusterBkg": "#EFE9DC", "clusterBorder": "#766F65"}}}%%
flowchart TB
S["Symbolic AI<br/>centralised reasoner"]
D["Distributed AI<br/>blackboard, Contract Net"]
U["The situated turn<br/>subsumption"]
I["The intentional stance<br/>Dennett's licence"]
A(["The modern agent idea"])
S ~~~ U
D ~~~ I
S -->|"deliberation"| A
D -->|"coordination"| A
U -->|"environment<br/>coupling"| A
I -->|"intentional<br/>vocabulary"| A
2 A Short History of Agents Pretending to Be Intelligent
The phrase “intelligent agent” has, for most of its history, contained at most one true word. For three decades the agents were real enough — pieces of software, dignified with autonomy and a great deal of theory — but the intelligence was largely promissory, a quality they were forever said to be on the verge of acquiring and somehow never did. This chapter is the story of that gap: of an idea worked out in loving detail long before anything could be built to fill it, of the disappointment that followed, and of the recent and slightly disorienting moment at which the missing piece finally arrived.
There is a second sense in which agents have always pretended. To call a piece of software an agent at all is to adopt what the philosopher Daniel Dennett named the intentional stance — to describe a system as though it had beliefs, desires, and goals, because doing so is convenient and predictive, whether or not anything inside it answers to those words. We say the thermostat “wants” the room warm; we say the chess program “believes” it is winning. The pretence is harmless, and often indispensable, so long as we remember that it is a pretence. A good deal of the history in this chapter is the history of a field forgetting, periodically and expensively, exactly that.
We rehearse this history not out of nostalgia but because it is, unusually, load-bearing. The central claim of this book is that the classical theory of agents and multi-agent systems was not wrong but premature: it described agents that could not yet be built. To take that claim seriously you have to know what the theory actually said, and you have to be able to tell the genuinely new from the merely rediscovered. The chapters that follow trade constantly on that distinction; this one supplies the timeline against which it is drawn.
What follows is a short and deliberately honest history — including the parts the field would rather forget: the over-promising, the killer application that never came, the standards that were ratified and then ignored. We begin with the roots of the agent idea in the distributed artificial intelligence of the 1970s and 80s; trace its theoretical high-water mark in agent-oriented programming and the belief–desire–intention model; revisit the boom of the 1990s and the disappointment that followed; note where the ideas quietly survived; and end at the reversal of fortune that has made a thirty-year-old body of theory suddenly, and urgently, relevant. The moral, stated in advance: the theory was largely sound and the timing was largely terrible, and it is worth knowing which was which — before the next wave of enthusiasm tempts the field to repeat the experiment.
| Phase | Roughly | What defined it | Where treated |
|---|---|---|---|
| Roots in distributed AI | 1970s–80s | Symbolic, distributed, and situated strands braid into the idea of an autonomous problem-solver | Section 2.1 |
| The classical synthesis | Late 1980s–mid-1990s | Practical reasoning (BDI), agent-oriented programming, and the logics of agency | Section 2.2 |
| The agent decade | 1990s | Delegation, mobile agents, and agent communication languages — each over-promised | Section 2.3 |
| The disappointment | Late 1990s–2000s | The hollow agent, the killer application that never came, and a retreat into rigour | Section 2.4 |
| The quiet vindication | 1990s–2000s (concurrent) | Auctions and mechanism design, RoboCup, and self-play carry the ideas into use; textbooks keep the theory intact | Section 2.5 |
| The reversal | 2020s | Foundation models supply the missing competence, and a premature theory becomes applicable | Section 2.6 |
2.1 Before the Agent: Roots in Distributed AI
The agent did not arrive fully formed; it emerged, over two decades, from a quarrel within artificial intelligence about what intelligence is and where it lives. One camp held that intelligence was centralised symbol-manipulation. A second held that it was better spread across many cooperating problem-solvers. A third held that much of it required no symbols at all. And a philosopher, standing slightly apart from the engineering, supplied the vocabulary that let all of them go on calling their programs agents with a clear conscience. By the end of the 1980s these strands had braided into something recognisable as the modern idea of an agent — and each left a residue the field still carries.
2.1.1 From Problem-Solvers to Agents
The founding bet of artificial intelligence was that thinking is computation over symbols. Newell and Simon stated it as a formal conjecture — the physical symbol system hypothesis, that a system manipulating symbol structures “has the necessary and sufficient means for general intelligent action” — and built programs, from the General Problem Solver onward, that reasoned by searching through spaces of symbolic states (1976). For two decades this paradigm more or less was artificial intelligence: a single, centralised reasoner, equipped with a model of its world, deducing what to do.
The trouble, increasingly apparent through the 1970s and 80s, is that the world rarely arranges itself around one omniscient reasoner. Real problems are spread across many parties, sensors, and machines; knowledge is local; and a single program large enough to hold everything tends to be brittle in proportion to its size. Out of this discomfort grew distributed artificial intelligence (Bond & Gasser, 1988) — the study of how several problem-solvers might divide labour and pool results. Its canonical early mechanisms are still familiar: the blackboard, on which independent specialists post partial solutions for one another to build upon, and the Contract Net protocol (Smith, 1980), in which a manager announces a task and contractors bid to perform it. These are recognisably the coordination problems of Section 1.1 — and the orchestrator of our running example is, stripped of its language model, very nearly a Contract Net manager. The word that gradually attached itself to the distributed pieces was agent: an autonomous problem-solver, one of many, getting on with its part.
2.1.2 The Situated Turn
While the distributed-AI faction was spreading symbolic reasoning across many machines, a more radical objection was forming: that the symbolic reasoning was itself the problem. In a series of pointed papers, Rodney Brooks argued that intelligent behaviour need not rest on an internal symbolic model of the world at all. His mobile robots achieved robust, almost lifelike behaviour through a subsumption architecture of simple, tightly coupled sensorimotor layers, with no central representation to speak of (1986); the accompanying manifesto, Intelligence without representation, put the case bluntly — that the world is its own best model, and that much of what looks like reasoning is better explained as the interaction between a situated body and its environment (1991).
Brooks overstated the case, as manifestos must, and the symbolic tradition did not oblige him by vanishing. But the situated turn changed the agent idea permanently. It established that an agent is coupled to an environment in a loop — sensing and acting over time — rather than computing in the abstract, the very framing we adopted in Section 1.2. And it bequeathed to every subsequent architecture an unresolved tension between deliberation (think first, then act) and reaction (respond now), which the hybrid architectures of Chapter 4 exist precisely to manage. The modern agent, interleaving a deliberating language model with fast tool calls and reflexes, is a direct descendant of that compromise.
2.1.3 The Intentional Stance
There remained an embarrassment at the heart of the enterprise. Researchers spoke freely of what their agents believed, wanted, and intended, while knowing perfectly well that the agents in question were a few hundred lines of Lisp. Was this loose talk, to be apologised for, or something more respectable?
The philosopher Daniel Dennett supplied the answer, and the licence. To predict the behaviour of a complex system, he observed, one may adopt any of several stances. The physical stance predicts from physics; the design stance predicts from how the thing was built; and the intentional stance predicts by treating the system as if it were a rational agent with beliefs and desires, and asking what such an agent ought to do (1987). The intentional stance is not a claim that the system really has a mind; it is a bet that ascribing one is the most economical way to anticipate its behaviour — a bet that pays off for thermostats and chess programs as readily as for people. The stance is instrumental, and serenely indifferent to what is actually inside.
This is the respectable name for agents pretending to be intelligent, and it is more than a philosophical nicety. It licensed an entire methodology: if treating a system as a believing, desiring, intending thing helps us to design and predict it, then belief, desire, and intention are legitimate engineering primitives, whatever the hardware beneath. The next section is the story of what happened when the field took that licence literally, and set out to build agents from exactly those primitives.
2.2 The Classical Synthesis: Agent-Oriented Programming and the BDI Model
Between the late 1980s and the mid-1990s the field produced its classical synthesis: a detailed, internally consistent account of what an agent is, how it reasons, and how one might program it — expressed, with some daring, in the very vocabulary of belief, desire, and intention that Dennett had made respectable. It was a genuine intellectual achievement, and it had one conspicuous defect, to which we shall return: almost nothing then in existence was clever enough to be the agent the theory described. The synthesis came in three layers — a model of practical reasoning, a programming paradigm built upon it, and a formal logic beneath — and we take them in that order.
2.2.1 Practical Reasoning and the BDI Model
Human beings do not, on the whole, reason afresh about everything at every moment; we form intentions — commitments to future courses of action — and then largely get on with them, reconsidering only when something forces us to. The philosopher Michael Bratman made this observation the centre of a theory of practical reasoning: an intention is not merely a strong desire but a distinct kind of mental state, a partial plan that we adopt, commit to, and thereafter use to filter further deliberation (1987). The whole point of an intention is that it resists reconsideration — an agent that re-derived its entire plan on every cycle would never get anything done.
Anand Rao and Michael Georgeff turned this philosophy into an architecture. The belief–desire–intention model — BDI — equips an agent with three structures and a loop over them: beliefs (what it takes to be true), desires or goals (what it would like to bring about), and intentions (the goals it has committed to, together with the plans it has selected to pursue them) (1995). On each cycle the agent revises its beliefs from perception, deliberates to settle its intentions, and acts; the craft lies in the balance between committing hard enough to make progress and reconsidering often enough to stay sane. This was not idle theory — the model was implemented and deployed, the Procedural Reasoning System and its descendants running real applications, including real-time fault monitoring for spacecraft (Georgeff & Lansky, 1987). And it should look familiar: the perceive–deliberate–act loop of a modern language-model agent, with its context (beliefs), its goal, and its chosen sequence of tool calls (intentions), is BDI with the serial numbers filed off.
2.2.2 Agent-Oriented Programming
If agents are best described in terms of beliefs and intentions, why not program them that way? This was Yoav Shoham’s proposal (1993), and it gave the field both a name and a manifesto. Agent-oriented programming was pitched as a new paradigm one level of abstraction above object-oriented programming: where an object has state and methods, an agent has a mental state — beliefs, capabilities, choices, commitments — and its behaviour is specified in terms of how those mental states evolve and how agents message one another to change them. Shoham even supplied a prototype language, AGENT-0, in which one programmed by writing commitment rules rather than procedures.
Agent-oriented programming never displaced object-oriented programming, and AGENT-0 is a museum piece. But the idea was prophetic in a way that is only now obvious. To program an agent by stating its commitments and letting it work out the rest is, more or less exactly, what one does in writing a system prompt for a language-model agent: a description of role, goals, and constraints, from which behaviour is meant to follow. Shoham proposed programming in the intentional vocabulary three decades before the tooling could honour the proposal.
2.2.3 The Logics of Agency
Beneath the architecture and the programming paradigm lay a third layer, the one of which the field was proudest: a formal logic of agency. If we are going to ascribe beliefs and intentions to machines, the reasoning went, we had better say precisely what those words mean — precisely enough to prove theorems about them.
The effort produced some genuinely deep results. Philip Cohen and Hector Levesque gave a formal account of intention as choice with commitment, deriving the properties an intention must have — including the delicate requirement that a rational agent eventually drop an intention once it believes the goal achieved, or believes it never will be (1990). Rao and Georgeff built a family of BDI logics on a branching-time model of possible futures, in which belief, desire, and intention become modal operators and one can state, and check, constraints on how a rational agent’s mental states must hang together (1991). This was the apparatus that filled the proceedings of the agent conferences through the 1990s, and it was, by the standards of the field, beautiful.
It was also the part that aged least kindly — not because it was wrong, but because the gap between a modal logic of intention and a deployable agent proved enormous, and the logics offered little guidance on how to cross it. A recurring pattern of this history is visible here in miniature: theory of great elegance, running far ahead of any artefact that could embody it. What happened when the wider world was promised the artefact regardless is the story of the agent decade.
2.3 The Agent Decade
With a theory this complete, the 1990s did what decades tend to do when handed a finished theory and a fast-growing internet: they got excited. Agents were declared the coming paradigm of computing — the successor to the desktop application, the thing that would finally make the network do one’s bidding. For a few years the prophecy was everywhere, in three principal forms: agents that would act for you, agents that would travel, and agents that would talk to one another. Each was a genuine and reasonable idea; each ran some distance ahead of what could actually be delivered; and each left behind concepts that the present moment is busily, and largely unwittingly, reinventing.
| The promise | What it was | Why it stalled | Where it resurfaces |
|---|---|---|---|
| Act for you (delegation) | Personal assistants learning your preferences — indirect management rather than direct operation | The right vision in the wrong decade: nothing intelligent to delegate to | The assistant that reads your mail and books your travel |
| Travel (mobility) | Code that travels — suspends itself, moves to the data or service, resumes, works | Security in both directions; remote calls worked and required trusting no one | Shipping computation to the data — without the agent framing |
| Talk to one another (communication) | Performatives naming the speech act performed (tell, ask, subscribe, achieve) |
Did not fail so much as wait — ratified with few agents to use it | Tool and agent protocols — the Model Context Protocol (MCP) and its kin (Chapter 8) |
2.3.1 The Dream of Delegation
The most seductive promise was delegation. In an influential essay, Pattie Maes described software agents as personal assistants — entities that would learn your preferences, watch over your shoulder, and quietly take work off your hands: sorting your mail, filtering your news, scheduling your meetings, recommending what you might like (1994). The metaphor was the human assistant, and the vision was indirect management: you would no longer operate your computer so much as delegate to it and supervise.
It was the right vision and the wrong decade. The interface agents of the 1990s could be trained, after a fashion, on your past behaviour, but they had no general understanding of the tasks they performed and no robust way to handle anything they had not seen before — which, in an open world, is most things. The dream of delegation did not fail because it was foolish; it failed because the agent had nothing intelligent to delegate to. A quarter of a century later, the assistant that reads your mail and books your travel is a product demonstration rather than a research aspiration, and Maes’s essay reads less like history than like a roadmap whose timing was off by a generation.
2.3.2 Agents That Travel
The second promise was mobility. Why should an agent sit still? In the architecture that briefly captivated the field, an agent was code that travels: a program that could suspend itself, move across the network to where the data or the service lived, resume, do its work, and move on. General Magic’s Telescript gave the idea a commercial vehicle; IBM’s Aglets gave it a Java one; and a small literature accumulated reasons why this was a good idea — reduced network load, the ability to operate while disconnected, a natural fit with intermittently connected devices (Lange & Oshima, 1999).
Almost none of it survived. Mobile agents foundered on problems less glamorous than the vision and more fundamental: security, above all — a host asked to execute arbitrary travelling code has every reason to be nervous, and an agent executing on an untrusted host cannot keep its own secrets either — together with the awkward fact that the alternative, calling a remote service over the network and leaving the code where it was, worked perfectly well and required trusting no one. The mobile agent is the purest example in this chapter of an idea of real charm that the world simply declined to need. Its ghost survives in every system that ships computation to the data rather than the reverse, but the agent framing did not.
2.3.3 Agents That Talk
The third promise, and the most consequential for this book, was communication. If agents were to cooperate, they had to speak; and a sequence of standardisation efforts set out to give them a shared language. The intellectual foundation was speech act theory — the observation, due to Austin and Searle, that an utterance is not merely a statement of fact but itself an action: to say “I promise” is to promise, to say “I request” is to request (1969). An agent communication language could therefore be organised around performatives — message types that named the speech act being performed.
Two such languages came to dominate. KQML, the Knowledge Query and Manipulation Language, wrapped content in an outer layer of performatives — tell, ask, subscribe, achieve — so that agents could not only exchange facts but say what they meant by exchanging them (Finin et al., 1994). The later FIPA-ACL, from the Foundation for Intelligent Physical Agents, set the same idea on a firmer semantic footing and became the field’s official standard. Both were serious, careful attempts at the genuine problem of agent interoperability — and both were ratified into a world that had very few agents to use them.
This is the one promise of the agent decade that did not so much fail as wait. The problem the communication languages were solving — how independently built agents discover one another, agree on meaning, and coordinate — is precisely the problem now resurfacing under the banner of tool and agent protocols, the Model Context Protocol (MCP) and its kin.1 We take up that lineage in detail in Chapter 8; for the moment, note only that the questions KQML asked in 1994 are being asked again, frequently by people who have never heard of it.
2.4 The Disappointment, Honestly Recounted
Why did none of it happen? The agent decade ended not with a bang but with a quiet reclassification: agent drifted from the name of computing’s future to a slightly awkward word one preferred to avoid in a grant application. It is tempting to blame the usual culprit, hype, and leave it at that. But hype is a symptom, not a cause, and the honest accounting this chapter promised requires naming the three things that actually went wrong. They were a missing capability, a missing application, and a loss of nerve.
2.4.1 The Hollow Agent
The deepest problem was also the simplest to state and the hardest to fix: the agents had nothing intelligent inside them. The decade had produced exquisite containers for intelligence — architectures that could deliberate, communicate, commit, and coordinate — and very little to put in them. A BDI agent could maintain beliefs and select intentions impeccably, but its beliefs had to be hand-crafted, its plans hand-written, and its competence in any new situation was exactly whatever its designers had anticipated, and no more. The autonomy was real; the intelligence was borrowed, in advance, from a human programmer.
This is what we will call the hollow agent, and it is the single most important fact in the history of the field, because it explains everything else. An autonomous shell around a brittle, hand-built core is autonomous in roughly the way a wind-up toy is alive. The field’s own assessments, even at the height of the enthusiasm, were candid about the gap: the contemporary roadmaps named knowledge acquisition, robustness, and the building of agents that could cope with the unexpected as open and largely unsolved problems (Jennings et al., 1998). They were right to. None of these was solved by better architectures, because none was an architecture problem in the first place. They were all waiting on a general-purpose source of competence that would not exist for another twenty years.
2.4.2 The Killer Application That Never Came
A technology can survive being early if it has one undeniable use — a single application so compelling that people tolerate the rough edges to get it. Agents never found theirs. The literature proliferated instead: by the mid-1990s a reader could choose between collaborative agents, interface agents, mobile agents, information agents, reactive agents, hybrid agents, and “smart” agents, a taxonomy that branched faster than any of its branches bore fruit (Nwana, 1996). The variety was itself a symptom; a field with a killer application does not spend its energy classifying itself.
Where concrete applications were attempted, the infrastructure fought back. Mobile agents, as we have seen, ran aground on security; agent platforms and communication standards were duly built, standardised, and left waiting for agents worth deploying on them. Meanwhile the ordinary, unglamorous web — pages, forms, and remote calls operated by people — quietly did almost everything the agents had been going to do, and did it without anyone having to trust a travelling program or agree on a logic of belief. The agent was a solution of considerable elegance, circling a problem that the rest of computing kept solving by cruder and more reliable means.
2.4.3 The Retreat into Rigour
Faced with promises it could not keep, the field did something both sensible and self-effacing: it retreated to ground it could defend. If general intelligent agents were out of reach, one could still make rigorous progress on well-posed fragments of the problem — and so the centre of gravity shifted, through the late 1990s and 2000s, from building whole agents to proving things about idealised ones. Game theory, mechanism design, distributed constraint optimisation, the formal logics of knowledge and intention: these had crisp definitions, hard theorems, and no dependence whatever on anyone first managing to build a competent agent.
This was a genuine intellectual flourishing, and a great deal of the most durable content of this book descends from it — Part IV especially. But it was also a narrowing. The word agent receded from the public vocabulary; the grand vision of delegation and autonomy was set aside as premature, which it was; and the field settled into a respected, mathematically serious, and largely invisible speciality. It had, without quite saying so, decided to wait.
2.5 The Quiet Vindication
Out of fashion is not the same as idle. While the word agent was unfashionable and the grand vision on hold, the ideas themselves did something the hype never managed: they went to work. The vindication, when it came, was quiet — it arrived without press releases, mostly under other names, and in places where the theory could be applied to a problem narrow enough to be solved. Two kinds of survival are worth recording: the ideas that found homes in the wider world, and the texts that kept the theory intact until the world came back for it.
2.5.1 Ideas That Found Homes
The most consequential survival was also the least heralded. The agent decade’s most rigorous achievement — mechanism design, the theory of how to structure an interaction so that self-interested parties are induced to behave well — turned out to underwrite one of the largest businesses in history. When search engines learned to sell advertising, they did it by auction; and the generalised second-price auction that came to allocate keyword advertising — selling, as its most famous analysis put it, billions of dollars’ worth of keywords — is mechanism design operating at planetary scale (Edelman et al., 2007). Tellingly, the industry arrived at that design by hand rather than deriving it from theory, and it is not incentive-compatible in the way the textbook mechanism is — which is exactly why the mechanism-design canon was needed to understand and tune it after the fact. The same body of theory ran the spectrum auctions by which governments sold the airwaves. The agents here were economic rather than robotic, and few of the engineers involved would have called their systems multi-agent — but the results that made them work came directly from the canon the field had retreated into.
Other ideas found narrower but equally real homes. RoboCup, launched in 1997 with the deliberately absurd long-term goal of fielding robots that could beat the human World Cup champions, gave multi-agent coordination a concrete, competitive, and durable testbed — teamwork, role allocation, and real-time planning, refereed annually (Kitano et al., 1997). And multi-agent learning produced, even in the lean years, results of startling quality: Gerald Tesauro’s TD-Gammon taught itself to play backgammon at championship level, with almost no human knowledge, simply by playing millions of games against itself (1995). Self-play in this same spirit — a system bootstrapping competence by playing itself — would go on to topple Go, poker, and StarCraft, by methods that grew well beyond Tesauro’s; the techniques and their discontents are the subject of Chapter 17, and the modern treatment is now a textbook in its own right (Albrecht et al., 2024). The thread connecting ad auctions, robot football, and self-play is that each took one well-defined fragment of the agent vision and made it pay — precisely the strategy the disappointment had forced upon the field.
2.5.2 Keepers of the Flame
While the applications carried the ideas into the world, a smaller act of preservation was under way in the literature. A handful of textbooks gathered up the scattered results of the agent decade — the architectures, the communication languages, the game theory, the logics — and set them down in coherent, teachable form, against a day when someone might need them. Michael Wooldridge’s An Introduction to MultiAgent Systems (2009) became the standard entry point, and Yoav Shoham and Kevin Leyton-Brown’s Multiagent Systems (2009) the rigorous game-theoretic reference. Both appeared in 2009, at what now looks like the very bottom of the field’s public fortunes, and both were written — as this book’s preface remarks of the first — entirely before the thing that would make their subject urgent had been invented.
That is the quiet vindication in a sentence: the theory was preserved, intact and unfashionable, by people who believed it correct even though they could not yet build much with it. They were right. But what none of them could supply — what no architecture, auction, or textbook could supply — was the missing core itself. Where that finally came from is the last turn of this history.
2.6 The Reversal of Fortune
For thirty years the field had everything except the one thing that mattered. It had architectures for agency, languages for communication, logics for intention, and a theory of interaction of real depth — a complete account, in effect, of how a competent agent should be structured and how competent agents ought to deal with one another. What it did not have, and could not manufacture, was competence itself: the general, flexible, faintly common-sensical capability that would let an agent cope with a situation its designers had not foreseen. The reversal of this chapter’s title is that the missing ingredient finally arrived — not from the agents community, which had given up expecting it, but from an almost unrelated quarter, and in a form nobody had predicted.
2.6.1 The Missing Piece Arrives
The ingredient came from machine learning, and specifically from the unglamorous-sounding project of training very large neural networks to predict the next word in a stretch of text. The surprise — and it was a genuine surprise, to the practitioners as much as to anyone — was that a model trained only to continue text, given enough scale and data, acquired something startlingly close to general competence: it could follow instructions it had never seen, reason its way through novel problems, and adapt to a new task from a handful of examples or a sentence of description (Brown et al., 2020) — and, as the models grew, write and debug code as well. This is precisely the capability the hollow agent had always lacked. A foundation model is not, in itself, an agent — it has no goals, no memory, no means of acting, and no loop, as Section 1.2 was at pains to insist — but it is exactly the deliberative core that the classical architectures had been built to house and could never fill. What the foundation model provides, and conspicuously does not, is the business of the next chapter; here it is enough to record the historical fact. After thirty years, the shell finally had something to put inside it.
2.6.2 Premature, Not Wrong
Place the two halves of this history side by side and the thesis of the book states itself. The classical theory of agents was not mistaken. Its account of practical reasoning, its communication languages, its logics of commitment, its game theory of interaction — these described real structure, correctly, and they failed to change the world for one reason only: there was nothing to instantiate them. They were premature. The arrival of the foundation model does not refute that theory; it completes it, by supplying at last the component every part of it had presupposed.
This is why the present book treats the classical literature as a live resource rather than a museum. The BDI loop is the modern agent loop (Section 2.2); agent-oriented programming is the system prompt; the agent communication languages are the tool and agent protocols; the auctions and mechanism design are about to govern fleets of agents spending real money. The old results were answers kept in storage, waiting for the questions to become askable. They are askable now. To build well with foundation-model agents is, to a degree that still surprises the engineers doing it, to reread a literature that has been sitting on the shelf, vindicated and unread, for a quarter of a century.
2.6.3 History Rhymes
It would be a fitting end to a chapter about over-promising if the chapter itself over-promised, so a closing caution is in order. The present moment has the unmistakable shape of the last one. The vocabulary of imminent, autonomous, delegating agents is back, almost verbatim from the 1990s; the demonstrations are dazzling and the production systems are flakier than the demonstrations let on; and a great deal of confident prophecy is once again running ahead of what anyone can reliably ship. The systems that string foundation models together still fail in ways a veteran of the agent decade would find familiar — miscoordinating, talking past one another, and coming apart in the face of situations no one anticipated (Cemri et al., 2025).
The crucial difference, this time, is that the missing capability is genuinely present: the agents are no longer hollow, and that changes what is possible in a way the 1990s never managed. But genuine capability is not the same thing as reliable engineering, and an intelligent core does not exempt a system from needing coordination, evaluation, accountability, and restraint — which is the entire burden of the rest of this book. The lesson of the last cycle is not that enthusiasm is wrong but that enthusiasm is not a method. The field forgot that once, expensively. Now that the agents can finally do something, it can afford to forget it even less.
2.7 Summary
- The theory came first. Agents were specified in loving detail — agent-oriented programming, the belief–desire–intention model, the logics of knowledge and intention — well before there existed anything intelligent enough to animate them.
- “Agent” was always partly a pretence. To call a system an agent is to adopt Dennett’s intentional stance: to describe it as having beliefs and desires because doing so is predictive, not because anything inside it answers to the words.
- The 1990s over-promised. Software agents, mobile agents, and agent communication languages were advertised as the coming paradigm of computing; the prophecy outran the product, and much of the apparatus was quietly abandoned.
- The decisive flaw was a hollow core. Classical agents had autonomy, communication, and architecture but no general competence to deliberate with — sound shells around missing contents.
- The ideas did not die; they went to ground. Auctions and mechanism design, multi-agent learning, and robot teams carried the classical results into real use under other names, while the canonical textbooks kept the theory intact.
- The reversal is recent and real. Foundation models supply the missing competence, and a premature theory becomes applicable — not because it was wrong, but because the timing has at last caught up.
- History rhymes, and that is the warning. This wave of enthusiasm has the shape of the last; the capability is genuinely new, but the failure modes — over-promising, and autonomy without judgement — are not, and remain easy to repeat.
2.8 Exercises
Exercise 1. The reviewer of the running-example team, asked to gate a merge, ends its transcript: “I believe this patch is safe: the suite passes, and no public interface changes.” Mechanically, the reviewer is a language model invoked afresh on a context assembled for each call; nothing inside it persists between calls. (a) State one concrete prediction about the reviewer’s behaviour that the intentional stance licenses, and explain, by Dennett’s own criterion for choosing among stances, why neither the physical stance nor the design stance is a serious rival here. (b) Construct a specific two-call sequence of events under which your prediction from (a) fails, for a reason the intentional vocabulary cannot express; your scenario must involve no new evidence about the patch. (c) Propose one engineering change to the reviewer that gives the ascription “believes” a real referent — the classical synthesis of Section 2.2 built exactly this structure — and say which failure in (b) it removes and which residual gap it leaves.
Exercise 2. Six messages pass within the team, stripped here to bare content: (M1) orchestrator to coder_a, “Make the retry back-off in fetch.py exponential, with a capped ceiling”; (M2) coder_a to orchestrator, “The integration suite already fails on an untouched main”; (M3) reviewer to tester, “Send me the outcome of every test run as soon as it completes”; (M4) tester to reviewer, “Run 118 complete: two failures, both in test_backoff”; (M5) orchestrator to coder_a, “Does your patch alter any public interface?”; (M6) coder_a to orchestrator, “Withdraw my report about main — my checkout was stale, and the suite passes”. Take the performative vocabulary of Section 2.3 with these glosses: tell, assert content the sender holds true; untell, retract an earlier tell; ask-if, ask whether content holds; achieve, ask the receiver to bring content about; subscribe, ask to be told of every change to an answer; sorry, decline because no informative reply can be given. (a) Wrap each of M1–M6 in the single most appropriate performative, with a sentence of justification each; where the vocabulary forces an awkwardness, name it. (b) Coder_b now writes to the orchestrator: “I will have the caching patch ready for review by tomorrow morning.” Show that no performative above wraps this message honestly; name the speech-act family that is missing; and explain, in terms of what the orchestrator can and cannot thereafter plan on, why a team that delegates work cannot do without that family. (c) Design the missing performative: give its name, the condition a sincere sender must satisfy, what its receipt licenses the receiver to do, and its retraction partner.
Exercise 3. A coder agent holds a plan with k = 4 steps remaining; executing a step costs a = 200 tokens. Before each step the repository may shift under the agent — a colleague merges a conflicting change — with probability q, independently at each opportunity; once shifted it stays shifted, and every step of the old plan executed thereafter is waste. A shift is noticed only when the agent deliberates. Consider the two poles of the balance Section 2.2 describes: the bold agent deliberates only when the plan is exhausted, executing all four steps come what may, while the cautious agent deliberates before every step, at d = 60 tokens per deliberation, and so catches any shift before wasting a step on it. Two overheads distinguish the policies — the bold agent risks wasted steps, the cautious agent pays its four deliberations — and every other cost, replanning included, falls equally on both and may be ignored. (a) Show that the bold agent’s expected waste in tokens is W_{\mathrm{bold}} \;=\; a \sum_{t=1}^{k} (1-q)^{t-1}\, q\, (k - t + 1), evaluate it at q = 0.25, and say which policy is cheaper there. (b) Re-evaluate at q = 0.05. (c) With a few lines of Python, locate to three decimal places the volatility q^* at which the two policies break even, and state in one sentence what this arithmetic makes of Bratman’s claim that the whole point of an intention is that it resists reconsideration.
Exercise 4. Four proposals, overheard in the 2020s. For each, (i) name its closest ancestor in this chapter — the specific idea, not merely the decade; (ii) diagnose why that ancestor stalled; and (iii) identify which term of your diagnosis the foundation model has changed and which it has not, ending with a one-sentence verdict: genuinely new, or rediscovered with the old problem intact? (A) A public registry in which agents post natural-language descriptions of what they can do; strangers’ agents query it at run time and strike up collaborations. (B) “Agent hibernation”: serialise a coding agent mid-task and resume it inside a customer’s private network, beside data that must not leave. (C) An orchestrator posts each subtask to its coder agents; each replies with a sketch of its intended approach and an estimate of its own fitness for the job; the subtask goes to the best reply. (D) A “chief of staff” that reads your inbox, books your travel, and schedules your meetings, so that you manage it rather than operate your computer.
Exercise 5 (project). Stage this chapter’s re-enactment: a minimal interpreter in the style of Shoham’s AGENT-0 (Section 2.2), in modern Python with the standard library only, playing the running-example team’s test-runner. Time is an integer tick t = 1, 2, 3, \dots; once per tick the agent wakes, processes its inbox in arrival order, and then performs whatever it is committed to at that tick. Its mental state is a set of beliefs — facts, each with the tick of its adoption — and a set of commitments — an action, a due tick, and the agent it is owed to. Its programme is not a procedure but a capability table and commitment rules. Messages come in three kinds: on inform(fact) the agent adopts the fact as a belief; on request(action, due) it commits and replies “accepted” precisely when the action is in its capability table, the due tick lies in the future, and no existing commitment occupies that tick — otherwise it replies “refused”; on unrequest(action, due) it drops the matching commitment owed to the sender and confirms with “dropped”. The capability table holds the single action run_tests, with room for at most one committed action per tick. A commitment, once adopted, is never reconsidered — only execution or an unrequest removes it — and a refusal, once issued, is never revisited. (a) Implement the interpreter: message kinds as an Enum; beliefs, commitments, and messages as dataclasses; the tick as a method returning the outgoing messages. Performing run_tests sends the (stubbed) result to the agent owed and adopts it as a belief. (b) Drive the agent through this script — tick 1: request(run_tests, 3) from coder_a; tick 2: request(run_tests, 3) from coder_b, then unrequest(run_tests, 3) from coder_a; tick 3: an empty inbox — and report every outgoing message and the commitment set with which the agent enters tick 3. Something in the outcome is at once perfectly correct and quietly absurd: say what, and which clause of the semantics produces it. (c) Send instead, at tick 1, request("rerun the tests that failed last night and say why", 2) from the reviewer. Point to the exact line of your interpreter at which this reasonable request dies, state what a programmer would have had to do in advance for it to succeed, and name the concept from Section 2.4 that your trace makes concrete.
Exercise 6 (lab). Fill the hollow agent. Supply the semantics of Exercise 5, verbatim — capability table, one-run-per-tick capacity, commitment rules, the never-reconsider clause — as the written instructions of a current conversational model or agent harness, and replay both of Exercise 5’s inboxes message by message, recording every reply. Compare the two agents along four axes: (i) predictability — what could you prove about each agent’s outgoing messages before running it? (ii) the out-of-vocabulary request of Exercise 5(c); (iii) fidelity — does the model respect the capacity rule, and does it spontaneously revisit coder_b’s refusal once the slot falls free? (the interpreter cannot; decide whether doing so would be a virtue or a violation of the semantics you gave it); (iv) assurance — what testing would each agent need before you let it gate anything that matters? Deliver the comparison as a table with rows easy, hard, and impossible and one column per formalism — the two halves of this chapter’s history, side by side. Record the model identifier and the date beside the table.
The convergence is not confined to agent-to-agent protocols. The interface to the model itself has run the same course — from each laboratory’s bespoke completion endpoint towards a shared, stateful shape that several laboratories are now converging on. Proprietary innovation, then a scramble to standardise: the pattern this book keeps pointing at.↩︎