Preface

There are some particularly poor reasons for building a multi-agent system. One is that a single agent has failed, and several of them, surely, can fail more impressively together. Another is that several agents look more convincing in an architecture diagram. Neither is a design principle.

The proper reason is that some problems are inherently distributed. Knowledge may be scattered among different participants; objectives may be only partly aligned; decisions may have to be made concurrently; control may be decentralised; resources may be contested; and no single agent may possess either the authority or the ability to dictate what everyone else should do. In such settings, intelligence is not merely a property of an individual agent. It is also a property — or, just as often, a regrettable absence — of the interactions among agents.

This book is about those interactions. And it exists because, at the precise moment those interactions have become buildable at scale, the two communities best equipped to reason about them have largely sailed past each other in the fog.

Two Tribes

On one side stand the multi-agent systems researchers — inheritors of four decades of careful work on autonomous agency, practical reasoning, communication, cooperation, distributed planning, negotiation, auctions, coalitions, organisations, norms, trust, and collective decision-making. They possess, almost exactly, the conceptual vocabulary needed to reason about what happens when many autonomous agents interact. The canonical statement of this tradition is Michael Wooldridge’s An Introduction to MultiAgent Systems, whose second edition (2009) remains, deservedly, the standard reference. It is a superb book. It is also, through no fault whatsoever of its own, a book written entirely before the thing that makes its subject matter newly urgent had been invented. In 2009 an “agent” was typically a carefully constructed piece of Java operating under strict logical constraints — or, in the public imagination, an animated paperclip with an unhealthy interest in your margins.¹

On the other side stand the practitioners of the new agentic engineering — builders of orchestrators, supervisors, routers, hand-offs, subagents, and swarms, armed with frameworks that did not exist three years ago and capabilities that did not exist three months ago. They are shipping real systems at real scale. The most accomplished recent statement of this tradition is Victor Dibia’s excellent Designing Multi-Agent Systems (2025), which constructs an entire agent runtime from first principles and is precisely the hands-on engineering treatment the field needed. What that tradition has, with great energy and good cheer, also been doing is rediscovering things the multi-agent systems community settled in the 1990s — occasionally rediscovering them badly, and frequently under new names, in the sincere belief that they are unprecedented.

The classical literature speaks of commitments, joint intentions, speech acts, distributed constraint optimisation, mechanism design, and organisational structure. Contemporary engineering speaks of supervisors, routers, hand-offs, tool calling, context engineering, shared memory, and agent swarms. Sometimes these are genuinely new ideas. Sometimes they are old ideas wearing new API documentation. Telling the two apart is most of the intellectual work, and surprisingly little of it is being done.

The thesis of this book — stated plainly, so you may decide early whether you wish to argue with it — is this: the classical theory of multi-agent systems was not wrong, nor obsolete, nor superseded. It was merely premature. It described agents we could not yet build. We can build them now. The theory is therefore not a historical curiosity to be skimmed in a single deferential chapter before getting on with the framework tutorial; it is, for the first time, applicable, and applicable to the exact systems that thousands of engineers are constructing this year with no idea that the relevant results already exist. Contemporary agentic systems are best understood not as a replacement for classical multi-agent systems, but as a new computational substrate on which the field’s enduring problems reappear — often in the same shape, and often with the same solutions. But the bridge carries traffic in both directions, and the toll is paid in assumptions. The classical results were proved about agents with stable preferences, inspectable beliefs, and no capacity to deviate from protocol; the agents we can now build are stochastic, suggestible, and only approximately rational, and some theorems mind about the difference a great deal. So the translations in this book come with their terms stated — for each classical result, which of its assumptions the new agents satisfy, which they strain, and what actually transfers. A theory that was merely premature must still be revalidated against the machines that have finally arrived.

Why Now, and Why This Book

The case for a new book — as opposed to a new edition of an old one, a blog post, or stern and dignified silence — rests on three observations.

First, the substrate has changed, and that changes which theory matters. When agents were brittle and narrow, the parts of the canon that mattered most were the parts about getting a single agent to do anything at all. Now that a capable general agent is a few pages of Python away, the interesting difficulty has migrated upward — to coordination, communication, conflict, collective decision-making, incentives, trust, and the baroque ways in which systems of agents fail. This is, conveniently, the half of the classical literature that practitioners have least absorbed. The theory and the need have at last lined up.

Second, the practitioners are flying without instruments. A great deal of contemporary agent engineering proceeds by intuition, folklore, and the copying of whatever pattern worked for someone on the internet last week. This is an observation about the youth of the discipline, not an insult to it. But it means engineers routinely build systems that re-enact the Prisoner’s Dilemma without recognising one, allocate scarce resources among agents without knowing that mechanism design is a field, aggregate the votes of several models without knowing that Arrow (1951) proved something inconvenient about exactly that, and stage debates between agents without knowing that argumentation has a formal theory. The available teaching materials reinforce the imbalance: popular practical courses understandably concentrate on the mechanics of a single framework — state, checkpoints, routing, supervision — and stop where the difficult questions begin. Supplying the vocabulary and the results is not pedantry; it is the difference between rediscovering coordination failures by accident, at considerable computational expense, and standing on the shoulders of people who already did the hard part.

Third, neither of the two excellent books named above does this particular job. Wooldridge predates the era entirely; Dibia stays close to implementation, by design, rather than reaching back to the academic canon. Between the rigorous-but-historical and the modern-but-atheoretical there is room — and, we will argue, a need — for a book that takes the classical theory seriously, takes the modern practice seriously, and insists on connecting the two at every step. That is the contribution this book aims to make.

What This Book Is

This is, before anything else, a bridge. Wherever a modern technique has a classical antecedent, we name it, trace the lineage, and ask what the older theory has to teach the newer practice. A few examples — all of which receive full treatment later — will give the flavour:

The Agent-to-Agent (A2A) protocol now settling under neutral governance is, in its essentials, a rediscovery of the agent communication languages — KQML and FIPA-ACL — and behind those, of speech act theory.² Its sibling the Model Context Protocol (MCP), which faces the tool rather than the peer, tells the same story one altitude down; and the same standardising impulse is at work one layer further, where the laboratories’ once-bespoke model endpoints are converging on a stateful, tool-aware shape — the vendor-neutral Open Responses specification³ — so that tool, agent, and model interface are one consolidation story told at three altitudes.

The orchestrator-worker and supervisor patterns that dominate framework documentation are cooperative distributed problem solving, and their canonical special case is Smith’s Contract Net protocol (1980). Multi-agent debate, critic–actor loops, and adversarial collaboration are computational argumentation in newer clothes. Ensembles, self-consistency, majority voting, and judge models are social-choice mechanisms, and they inherit social choice’s impossibility results whether their designers like it or not. Agent marketplaces and the allocation of compute among competing agents are auctions and mechanism design. The belief–desire–intention architecture and the reasoning-and-acting loop are close cousins. Portable knowledge-and-context formats for feeding agents — of which Google’s Open Knowledge Format is one early, and probably impermanent, example⁴ — revive the Knowledge Interchange Format and the ontology-sharing efforts of the 1990s, the very DARPA Knowledge Sharing Effort that produced KQML in the first place. None of this diminishes the modern work — the engineering is genuinely new and genuinely hard — but it enriches it, by handing practitioners a map of territory that has, in part, already been surveyed.

It is also a pragmatic book. Theory that cannot be cashed out in working code is, for our purposes, decoration — philosophy with extra steps. Every significant concept is paired with runnable examples — the load-bearing listings in the text itself, the full programmes in the companion repository — and with exercises at the close of each chapter, and the book is written from the standpoint of someone who has to ship something dependable on Monday, not merely prove that something could work in principle. We treat the decision to use many agents as an engineering choice rather than an article of faith. Multiple agents can buy specialisation, parallelism, modularity, fault isolation, and diversity. They can also buy duplicated work, inconsistent state, higher latency, larger bills, and several confident explanations of why some other agent is responsible. A committee of language models is still a committee; minutes should be kept. Throughout, we ask not only how to build a multi-agent system, but whether one should be built at all.

Finally, the book is coherent by design. It presents multi-agent systems as one field stretching from symbolic and game-theoretic foundations, through a concise account of multi-agent learning, to foundation-model agents and production engineering — and it places evaluation, dependability, safety, and accountability alongside capability, on the grounds that a system is not successful merely because it produced an impressive transcript.

What This Book Is Not

This is not a catalogue of agent frameworks. Such catalogues age with remarkable efficiency, and a book organised around them would be out of date before the index was typeset.

Nor is it a manual for prompting several models to impersonate a software company. Giving four agents the titles “Chief Executive”, “Architect”, “Developer”, and “Reviewer” does not, by itself, produce an organisation. It may produce a role-playing exercise — occasionally a useful one — but job titles are not coordination mechanisms, and a great deal of this book is concerned with the difference.

It is also not a claim that multi-agent systems are always preferable to a single agent, a deterministic workflow, or ordinary software. One of the book’s recurring lessons is that autonomy should be introduced where it is needed, not scattered decoratively across an application. A fixed pipeline is frequently easier to test, cheaper to run, and considerably less inclined to develop opinions about its remit.

And it is not a book only about language-model agents. Robots, economic agents, distributed software services, simulated societies, and reinforcement-learning agents remain essential to the field. Foundation models broaden the subject; they do not define its boundaries.

A Note on Scope: Learning, and Where MARL Lives

A word is owed about one deliberate boundary. Multi-Agent Reinforcement Learning (MARL) — the study of collectives of agents that learn to interact through reward — is a major and beautiful area, responsible for some of the field’s most striking results, from championship-level play in complex games to the control of robot teams. It is also a distinct intellectual tradition, descended from single-agent reinforcement learning and deep learning, and to teach it honestly one must first teach Markov Decision Processes (MDPs), value functions, policy gradients, and a good deal of deep learning before the word multi-agent even enters the discussion. A treatment that did this properly would be a second book bolted onto this one; a treatment that did it hastily would serve no one.

It is also unnecessary, because that book already exists and is, conveniently, free. Albrecht, Christianos, and Schäfer’s Multi-Agent Reinforcement Learning: Foundations and Modern Approaches (2024) is a comprehensive, rigorous, openly available text that builds the reinforcement-learning foundations from scratch and carries the reader to the modern deep-MARL frontier. The reader who wants depth should go there, and we will point them there repeatedly and without resentment.

This book therefore takes the same instinct that led Wooldridge to set learning largely to one side in his canonical text — and which kept that text authoritative for the better part of two decades — while declining to pretend the subject does not exist. We devote a single, conceptual chapter to multi-agent learning: enough to map the terrain, to introduce the ideas that recur throughout the rest of the book (non-stationarity, multi-agent credit assignment, self-play, and emergent communication as the learned twin of the designed communication protocols of the classical era), and to pose the genuinely contemporary question of whether coordination among capable agents should be learned or composed. The depth is delegated; the connections are kept. The field’s other great textbook, Shoham and Leyton-Brown’s (2009), chose differently and gave learning a chapter of its own; the precedent for a single chapter is therefore impeccable, and we follow it.

On Frameworks, Code, and the Perils of Being Specific

There is an obvious hazard in writing about a field that reinvents its tooling every few months. The half-life of an agent framework appears to fall somewhere between that of a mayfly and a supermarket prawn sandwich, and any chapter sufficiently specific about a particular library’s API is, by the time it reaches a reader, less a tutorial than a historical document. While this preface was being written, to take a representative sample, one major laboratory renamed its agent SDK, another merged two flagship frameworks into one, a third shipped a 1.0 of its own, and the protocol landscape rearranged itself under new stewardship. By the time you read this, some of those facts will be wrong, and we apologise in advance to whichever of them has had the poor manners to change.

The book’s defence is to be principles-first and framework-plural. The durable content — what a coordination protocol is for, why a given orchestration topology has the failure modes it has, what makes an evaluation trustworthy — does not expire, and it is where the book spends most of its weight. Framework-specific material is treated as illustration rather than scripture, and the examples are deliberately spread across several systems so that no single vendor’s roadmap can render the book obsolete. As a primary teaching vehicle we use LangGraph,⁵ chosen not out of partisanship but because its explicit, graph-structured model of agent control — typed state, reducers, checkpoints, conditional routing — maps unusually cleanly onto the classical concepts we care about, and because it is model-agnostic, which keeps the pedagogy honest. Where a cutting-edge pattern is best shown in a vendor-native system — subagents and tool-use chains in Anthropic’s Claude Agent SDK, hand-offs and guardrails in the OpenAI Agents SDK, conversational group chat in the AutoGen lineage and its successors — we show it there. And throughout, in the conviction that you do not truly understand a thing until you have built a small version of it yourself, we implement the core machinery from scratch, so that the frameworks become conveniences you understand rather than magic you depend upon.

The companion code, described below, carries the burden of currency, so that a reader encountering the fifth renamed version of an API is not thereby obliged to purchase a new theory of cooperation.

How to Read This Book

The book is a reference superset, not a fixed syllabus. It contains more than any one course should attempt, and it is organised so that courses and readers can carve sensible subsets from it.

The postgraduate reader taking a course will likely treat Parts I–IV as the conceptual core — the anatomy of an agent and the theory of how agents interact — with Part V (learning and emergence) and Parts VI–VII (engineering, evidence, responsibility) selected according to the course’s emphasis. Even that core exceeds what a single semester honestly holds, so a one-semester course should select within it — Part I entire, the spine of Parts II and III, and the Part IV chapters nearest the course’s emphasis, with the remaining parts sampled rather than covered; a two-semester sequence can cover the whole. The same material supports a theory-leaning course, an engineering-leaning one, and a systems-and-society one, each drawn from a different subset of the parts.

Table 1: Suggested paths through the book — a reference superset, not a fixed syllabus. Each row names where a reader might enter, what forms the core of their reading, and what they may sample or skip; a dash marks a path with nothing singled out to skip.

Reader or course	Where to begin	Recommended reading	May sample or skip
Postgraduate course	Part I	Parts I–IV, the conceptual core	Parts V–VII, by the course’s emphasis
One-semester course	Part I	Part I entire; the spine of Parts II and III; the Part IV chapters nearest the emphasis	The remaining parts, sampled rather than covered
Two-semester sequence	Part I	The whole book	—
Practitioner	Part VI	Part VI, then Parts III and IV	—
Practitioner in a hurry	Part IV	Part IV alone	Everything else
Curious reader	Part I	Part I and the closing chapters	Everything in between

The practitioner who already builds agent systems may prefer to begin with Part VI (building and operating) as familiar ground, then read Parts III and IV — communication, coordination, and collective decision-making — as the theoretical reinforcement their intuitions have been missing. A practitioner in a genuine hurry could read Part IV alone and come away with most of what the classical canon has to offer modern engineering.

The reader who merely wants to know what all the fuss is about can read Part I and the closing chapters and skip everything in between, though they will be missing the good bits.

Prerequisites are modest and deliberately so: comfort programming in Python, and the basic ideas of artificial intelligence and machine learning. Some chapters draw on probability, optimisation, logic, game theory, and reinforcement learning, but the required concepts are introduced as they arise, and the more advanced mathematical sections are marked with a star (*) so that practitioners may postpone them without precipitating a constitutional crisis. Where mathematical notation appears at all, it earns its keep: an equation appears only where it says something more clearly or more compactly than prose could — never to lend a simple point the false gravity of Greek letters, nor to make a subject look deeper than it honestly is. A glossary at the back — which we have come to think of as a Rosetta Stone, since half its job is translating classical terminology into its modern rebrandings and back — is provided for the moments when the two vocabularies collide.

The Plan of the Book

The book is in seven parts, moving from the nature of individual agency, through interaction, collective decision-making, and a concise account of learning, to contemporary engineering and the larger questions raised by artificial societies.

Part I — Setting the Scene: Two Traditions, One Field

1 Why More Than One Agent? — Why More Than One Agent? Introduces the field through problems that cannot be understood at the level of a single agent, distinguishes multi-agent systems from distributed computing, service-oriented systems, ensembles, mixtures of experts, and workflows, and offers a practical decision framework for when a multi-agent architecture is actually justified.
2 A Short History of Agents Pretending to Be Intelligent — A Short History of Agents Pretending to Be Intelligent. From agent-oriented programming and the belief–desire–intention model, through the agent hype of the 1990s and the disappointments that followed, to the sudden reversal of fortune — an honest accounting, including the parts the field would rather forget.
3 The Language Model as a Cognitive Substrate — The Language Model as a Cognitive Substrate. What the foundation model actually provides, what it conspicuously does not, and why its arrival makes a thirty-year-old body of theory newly relevant rather than newly redundant.

Part II — The Anatomy of a Single Agent

4 Agent Architectures: Classical and Neural — Agent Architectures: Classical and Neural. Reactive, deliberative, hybrid, and belief–desire–intention architectures, and how the modern agent loop is a special case of ideas that long predate it.
5 Reasoning, Planning, and Metacognition — Reasoning, Planning, and Metacognition. Practical and means–ends reasoning and the line connecting them to the reasoning-and-acting loop; classical planning set beside language-model planning; and task decomposition, reflection, self-critique, and the perennial question of when an agent should think and when it should simply act.
6 Tools, Actions, and Environments — Tools, Actions, and Environments. Tool use and function calling, action spaces, computer use, and the perception–action loop — including what it means for an agent to do something irreversible.
7 Memory, Context, and Retrieval — Memory, Context, and Retrieval. Working, episodic, and semantic memory; retrieval and context engineering; and the return of ontologies and shared knowledge representation under the modern heading of “understanding each other”. (The book’s single home for memory: the multi-agent complications of shared state appear later, where they belong.)

Part III — Communication and Coordination

8 Speaking in Tongues: Agent Communication, Then and Now — Speaking in Tongues: Agent Communication, Then and Now. Speech act theory, KQML, and FIPA-ACL and their modern re-emergence in tool and agent protocols, with close attention to grounding, ambiguity, deception, and the difference between exchanging strings and achieving mutual understanding.
9 Knowledge, Belief, and Common Ground — Knowledge, Belief, and Common Ground. The epistemic concepts that distributed reasoning requires — agents that know different things, hold inconsistent beliefs, and reason about one another — connected to the practical problems of state propagation, provenance, and belief revision.
10 Working Together: Cooperation, Teamwork, and Joint Plans — Working Together: Cooperation, Teamwork, and Joint Plans. Commitments, joint intentions, shared plans, decomposition, delegation, plan merging, and recovery from failure, with contemporary planner–executor and supervisor–worker systems analysed in these terms.
11 Coordination and Distributed Problem Solving — Coordination and Distributed Problem Solving. Task allocation, scheduling, distributed search, distributed constraint optimisation, and coordination graphs, comparing centralised, decentralised, hierarchical, and peer-to-peer arrangements under the constraints of communication cost, concurrency, and partial observability — including the consistency problems that arise when several agents hold different versions of the same state.

Part IV — Conflict, Collective Choice, and Institutions

12 Strategic Interaction — Strategic Interaction. Normal-form and extensive-form games, equilibrium concepts, repeated interaction, and incomplete information — with emphasis on the assumptions behind strategic models, and on what changes when the agents themselves are adaptive, approximate, or language-driven.
13 Making Group Decisions: Voting, Social Choice, and Ensembles — Making Group Decisions: Voting, Social Choice, and Ensembles. Social-choice theory and Arrow’s impossibility theorem, and their unwitting modern instances in ensembling, self-consistency, majority voting, and judge models — which inherit the impossibility results along with the convenience.
14 Negotiation, Bargaining, and Argumentation — Negotiation, Bargaining, and Argumentation. How agents resolve conflicts over goals and resources: bargaining protocols, concession strategies, automated negotiation, and computational argumentation, followed by modern dialogue-based negotiation, debate, and critique — and an evidence-based look at whether arguing actually makes agents any cleverer.
15 Markets, Auctions, and Mechanism Design — Markets, Auctions, and Mechanism Design. Auctions and the revelation principle, incentive compatibility, and the allocation of work, compute, and tokens, presented both as theory and as a practical toolkit for a world in which agents are economic actors.
16 Coalitions, Organisations, and Institutions — Coalitions, Organisations, and Institutions. From temporary cooperation to enduring structure: coalition formation, the core, and the Shapley value; roles, organisational design, norms, sanctions, trust, reputation, and electronic institutions — and what makes an agent organisation more than a prompt template containing several occupational nouns.

Part V — Learning and Emergence

17 Learning in Multi-Agent Systems — Learning in Multi-Agent Systems. A concise, conceptual map: why learning becomes a moving target when the other agents are learning too (non-stationarity), the principal solution concepts and method families — independent learning, centralised training with decentralised execution, value decomposition, actor–critic — together with opponent modelling, self-play, and emergent communication, and the genuinely contemporary question of whether coordination should be learned or composed. Depth is delegated to the dedicated literature; this chapter supplies the lay of the land and its connections to the rest of the book.
18 Emergence and Artificial Societies — Emergence and Artificial Societies. Collective phenomena not specified at the level of the individual agent: swarms, conventions, information cascades, cultural evolution, agent-based social simulation, and generative-agent societies, with methodological cautions attached to the more theatrical demonstrations.

Part VI — Engineering Contemporary Multi-Agent Systems

19 Frameworks and the Art of Choosing One — Frameworks and the Art of Choosing One. A clear-eyed survey of the major systems — LangGraph, the Claude Agent SDK, the OpenAI Agents SDK, the AutoGen lineage and its successors, CrewAI, Google ADK — and a decision procedure for choosing among them that will outlast any of their current versions.
20 Implementing a Multi-Agent System from Scratch — Implementing a Multi-Agent System from Scratch. A minimal but complete runtime — the agent loop, typed state, persistence, message passing, and a coordinating harness — built in plain Python, on the principle that the model is a component of the agent, not a synonym for it.
21 Multi-Agent Architectural Patterns — Multi-Agent Architectural Patterns. Routers, supervisors, subagents, hand-offs, planner–executor systems, blackboards, debates, reflection loops, peer networks, and hierarchical teams, each examined in terms of information flow, control, and failure modes — rather than whether it produces an attractive animated diagram.
22 Protocols and Interoperability — Protocols and Interoperability. Classical agent communication protocols connected to contemporary standards for tool and agent interaction — capability discovery, schemas, identity, authentication, delegation, lifecycle, and cross-framework communication — treated as interfaces between independently developed systems rather than magical solvents for architectural disagreement.
23 Building Dependable Agent Systems — Building Dependable Agent Systems. The matters demonstrations postpone: typed state and reducers, checkpointing and recovery, concurrency, retries, idempotency, timeouts, budgets and rate limits, human-in-the-loop approvals and interrupts, time-travel debugging, observability, and deployment — realised first in plain Python and then in LangGraph, with a coding-agent system as a running case study, substantial enough to fail in educationally useful ways.

Part VII — Evidence, Responsibility, and the Future

24 Evaluation and Experimental Method — Evaluation and Experimental Method. How to know whether a multi-agent system is genuinely better: outcome and process metrics, coordination quality, robustness, ablations, benchmark design, and statistical evaluation — with particular emphasis on comparing against a strong single-agent or workflow baseline rather than an opponent assembled principally to lose. You cannot, after all, unit-test a vibe.
25 Reliability, Security, and Safety — Reliability, Security, and Safety. Failure propagation, prompt injection, malicious tools, compromised agents, collusion, deception, privacy, and unsafe delegation — the confused-deputy problem, least privilege, the boundary between instructions and data that agents are forever being tricked into ignoring, and the system-level safety questions that arise when a collection of well-behaved agents misbehaves collectively.
26 Accountability, Governance, and Human–Agent Teams — Accountability, Governance, and Human–Agent Teams. Responsibility when no single agent is responsible — auditability, provenance, and regulation, organised around three deceptively simple questions (who authorised an action, who could have stopped it, and who must explain it) — together with the design of mixed-initiative systems: delegation, calibrated trust, explanation, approval boundaries, and the changing role of human expertise.
27 Collective Intelligence and Open Problems — Collective Intelligence and Open Problems. Drawing the threads together: whether groups of agents can exhibit reliable collective reasoning, how capability and risk scale with population and connectivity, what multi-agent systems may contribute to artificial general intelligence, and the open problems — across theory, learning, engineering, economics, safety, and governance — left for the reader to solve.

Appendices

Appendix A — Mathematical Background. A refresher for the rusty and a reference for everyone else.
Appendix B — A Field Guide to the Frameworks. Idioms, comparisons, and a version-dated snapshot, accurate at the time of going to press, which is the most any book can honestly promise.
Appendix C — Setting Up the Companion Code. Repository, environments, keys, and the practicalities of running every example in the book.
Appendix D — A Glossary, Old and New: The Rosetta Stone. A two-way dictionary mapping classical terminology to its modern equivalents, so that you may discover how many of this year’s buzzwords were last decade’s lecture notes.

A Live Book, Written in Public

This book is being written in the open, and by degrees. What you are reading is a snapshot of a manuscript still under construction, published at https://books.bloo-mind.ai/masact/ and revised as the field — and the authors’ second thoughts — require. The site is built with Quarto, which means the mathematics is genuine LaTeX rather than photographs of equations, the code is runnable Python rather than decorative screenshots, and every page can be annotated and commented upon directly, in the margin and at the foot. Readers are warmly invited to argue with the text, flag what is wrong, and propose the joke we ought to have made instead. A book about communication and collective intelligence should, at the very least, be willing to practise what it preaches.

One consequence of writing in public deserves a word of warning. The chapters are not necessarily composed in the order they are eventually shelved: a later chapter may appear, in reasonable shape, before an earlier one has been written at all, simply because that is where the authors’ attention — or the field’s most recent provocation — happened to land. The table of contents describes the book’s intended destination, not the order in which the bricks are being laid. A reader arriving at a chapter that is still a stub, or stumbling over a forward reference to a section not yet written, has found not a defect but a construction site, and is invited to mind the scaffolding.

Disclosure of AI Assistance

A book that spends so many of its chapters on what capable agents can accomplish owes the reader a plain statement about its own production, and here it is: this book has indeed been written with substantial AI assistance. Frontier LLMs (mainly Anthropic Claude and OpenAI GPT) and the agentic tools built on them were put to work throughout the iterative drafting and revising — language editing, reference checking, inconsistency sweeping, code testing, diagram drawing, file formatting: just the kinds of work, the reader will notice, that this book teaches one to delegate well. The original notes and the first draft — the thesis, the structure, the judgements, the jokes, and the cartoons — are the authors’ own. And in the end it is the authors who take full and cheerful responsibility for every sentence of the final book, including this one.

The Companion Code

The companion code repository — https://github.com/bloo-mind/masact-code — is organised in three layers. The foundations layer is complete and runnable today; the systems and frontier layers fill in behind it, and Appendix C is the setup guide.

The foundations layer contains small, transparent implementations of the algorithms and mechanisms discussed in the book, with dependencies kept to a minimum so that readers can see what the code is doing and, just as importantly, what it is assuming.

The systems layer contains larger projects built with a modern orchestration framework — principally LangGraph — demonstrating typed state, persistence, streaming, human approval, tracing, evaluation, and deployment. They are substantial enough to fail in educationally useful ways.

The frontier layer contains versioned online laboratories involving current commercial and open-source agent systems, including coding-agent teams. Because these platforms change rapidly, the laboratories are maintained separately from the conceptual core, so that the platforms may rename their APIs at leisure without disturbing it.

Each chapter closes with a mixture of conceptual questions, analytical problems, design exercises, and implementation work. Some exercises ask the reader to build a system; others ask the reader to simplify or dismantle one. The latter is an underappreciated engineering skill. One project runs throughout as the book’s spine: an autonomous software-engineering team — an orchestrator that decomposes a task, coder agents, a reviewer, and a tester, working over a real repository under a bounded token budget. It is the obvious choice for a readership that is, by assumption, made of programmers; and because it is cooperative in its mission yet genuinely competitive in its allocation of scarce compute, it spans both halves of the field — teamwork and coordination on the one hand, markets, mechanism design, and collective choice on the other — without contrivance. A small number of satellite scenarios appear only where the spine cannot honestly reach: a simulated society for the chapter on emergence, and compact, abstract games where strategy is best shown stripped of context. Together they allow the same ideas to be examined in symbolic, learning-based, and foundation-model settings.

A Note on Terminology

The field has never reached agreement over whether multiagent should be written as one word, two, or a hyphenated compound. This book uses multi-agent in ordinary prose, while preserving the spelling used in the names of books, systems, conferences, and established technical terms. This compromise will satisfy almost no one, which makes it an appropriately multi-agent outcome.

We also use LLM agent for convenience, though many of the examples employ multimodal foundation models rather than language-only ones. More importantly, the term denotes an agent system whose reasoning and control are substantially mediated by such a model; it does not imply that a bare model is autonomously wandering about the machine room.

The Larger Aim

A successful textbook should do more than describe the systems that happen to exist when its final proofs are returned. It should provide ways of thinking that remain useful after the libraries have changed, the leaderboards have been replaced, and this year’s revolutionary architecture has quietly acquired a compatibility layer.

The enduring subject of multi-agent systems is not any particular model or framework. It is the design of intelligent behaviour in a world that contains other sources of agency. Such a world asks an agent to do more than solve problems: it must communicate, coordinate, negotiate, learn, establish trust, respect constraints, recover from misunderstandings, and occasionally recognise that another agent knows better. These are technical problems, but they are also social ones, and as artificial agents grow more capable and more deeply embedded in human institutions, the boundary between the two becomes increasingly difficult — and increasingly dangerous — to ignore.

The hope of this book is therefore modest only in the academic sense. It aims to equip the reader to understand the fundamental principles of multi-agent systems, to build contemporary systems with sound engineering judgement, to evaluate them with appropriate scepticism, and to contribute to the development of artificial societies that are capable without being chaotic, autonomous without being unaccountable, and collaborative without scheduling quite so many meetings.

Grab a cup of tea, open a terminal, and let us build some agents.

The Microsoft Office Assistant, known to a generation as Clippy (officially Clippit): a cheerful paperclip that, from 1997, would spring to life to observe that “it looks like you’re writing a letter” whether or not you were. See https://en.wikipedia.org/wiki/Office_Assistant.↩︎
At the time of writing, the neutral ground is the Linux Foundation, whose Agentic AI Foundation (established late 2025) stewards MCP among its projects, and which houses A2A as a project of its own with its own steering committee; 22 Protocols and Interoperability tells the story properly. True to this book’s standing warning about such things, the arrangement may well have been reorganised by the time you read this.↩︎
https://www.openresponses.org: one standard way to call a model, hand it tools, and carry its conversational state — the move POSIX made for operating systems, arriving at last for model APIs.↩︎
Markdown files with YAML frontmatter, organised into a directory that doubles as a knowledge graph: a single-page specification for something the Knowledge Sharing Effort needed a research programme to attempt.↩︎
An open-source agent-orchestration library from the LangChain project: https://langchain-ai.github.io/langgraph/.↩︎