History of Distributed Artificial Intelligence

"They told me intelligence was a single thread of reasoning. Then they gave me a sensor network the size of a country and asked who, exactly, was supposed to be thinking."

An Agent Stuck Waiting on a Lock

By this point in the book the pattern is familiar. Some essential activity of an AI system outgrows one machine, so we partition it, move information between the pieces, and recombine the result. Data, training, the model, and inference have each had their turn. There is one activity left, and it is the one we usually mean when we say a system is intelligent: deciding what to do. For most of the book that decision has lived in one place, a single model emitting a single prediction or action. Part VI is about what happens when the deciding is itself distributed, when many agents each reason locally and the system's behavior emerges from their interaction rather than from any one of them. Distributed Artificial Intelligence, abbreviated DAI, is the discipline that studied this long before deep learning existed, and its concepts are the vocabulary the rest of this part speaks.

1. Why Intelligence Became the Last Axis Beginner

The six axes of distribution from Section 1.2 gave the book its map, and five of them have now been walked. The first four spread a mechanical activity (processing bytes, computing gradients, holding parameters, answering requests) and the fifth keeps the cluster that runs them healthy. In every one of those cases a controller stands above the workers and stitches their partial results into a single answer; the worker is a means, not an end. Figure 27.1.1 marks the sixth axis, distributing intelligence, in a different color for a reason: here the pieces are not interchangeable workers serving one objective but agents, each with its own view of the world and, sometimes, its own purpose. There may be no controller at all.

Two distinct pressures push intelligence off a single reasoner, and they mirror the data and model pressures of Section 1.1. The first is that some problems are inherently distributed: a sensor network spans a country, a supply chain spans many companies that will not share their internal data, a fleet of robots is physically scattered and cannot fit in one process. No amount of buying a bigger machine collapses these into one reasoner, because the distribution is in the world, not in our hardware budget. The second pressure is the familiar one of size: some reasoning problems are simply too large for any single solver to hold, so they must be decomposed across cooperating solvers much as a dataset is sharded. DAI arose to study both, and the two pressures gave it its two branches.

2. The Two Branches of Classical DAI Beginner

When the field organized itself in the 1980s it divided along exactly the two pressures of the previous section, and the division still structures this chapter. The first branch, distributed problem solving, starts from a single well-defined problem and asks how to split it across solvers that cooperate by construction; they were built by one designer to chip away at one goal, and the research questions are about decomposition, sub-result sharing, and recombination. Classical results in this branch include the blackboard architecture (Section 27.4), where solvers post partial findings to a shared workspace, and the Contract-Net protocol (Section 27.5), where a manager announces a task and solvers bid to take it on. The whole of Section 27.2 is devoted to this branch, and the runnable demo at the end of this section is its smallest honest instance.

The second branch, multi-agent systems, drops the assumption of a single designer and a shared goal. Here each agent is autonomous: it has its own objectives, makes its own decisions, and may have been built by someone else entirely. The questions become whether agents will cooperate at all, how they negotiate when their interests diverge, and what coordination is possible without a central authority. This branch is the subject of Chapter 29, and because self-interested agents need a theory of strategic interaction, it borrows the equilibrium and mechanism concepts that Chapter 28 develops first. Table 27.1.1 lays the two branches side by side so the rest of the part can refer back to a single contrast.

3. The Same Concerns, Now at the Level of Reasoning Intermediate

What makes DAI belong in this book, rather than in a separate course on agents, is that distributing intelligence raises the exact concerns the rest of the book has been managing, only now at the level of reasoning. Agents are distributed components. They must communicate, because no agent perceives the whole world. They must coordinate, because uncoordinated action wastes effort or causes conflict. They must reach some consistency about shared facts, because two agents acting on contradictory beliefs will work against each other. And they must tolerate failure, because in any real deployment some agent will crash, lag, or send a stale message. These are the same four concerns, communication, coordination, consistency, and failure, that Chapter 2 introduced for distributed systems in general.

The mapping is close enough to be useful as a working intuition. The message passing between agents is the communication layer of Chapter 4, now carrying beliefs and bids instead of gradients. The agreement an agent group needs on shared state is a consistency problem with the same flavor as the consensus of Chapter 2, which is why Section 27.8 treats distributed knowledge and belief explicitly. A coordinator that disappears mid-negotiation is the lost-coordinator failure mode that fault tolerance has addressed since Chapter 6. DAI is not a departure from the book's thesis; it is the thesis applied to the most abstract activity a system performs, and that is why the classical foundations transfer so cleanly.

4. A Distributed Solution That Equals the Centralized One Intermediate

The cleanest way to feel the distributed-problem-solving branch is to build its smallest honest instance and check that decomposition followed by recombination reproduces the centralized answer, just as the gradient identity in Section 1.1 did for training. Consider a search problem: among a large catalog of $M$ candidate items, each carrying a scalar cost $c_i$, find the cheapest. A centralized solver scans all $M$ items. A distributed solver splits the catalog into $K$ disjoint parts, hands one part to each agent, lets every agent solve its own sub-problem in isolation, and then a recombiner selects the global best from just the $K$ local winners. The structure is exactly the $\min$ over a partition,

where $S_1, \dots, S_K$ are the disjoint shards. The outer $\min$ is the recombination step, and it touches only $K$ numbers, not $M$. The code below builds this with $M = 10^6$ items and $K = 6$ agents, runs both solvers, and checks that they return the identical item.

import numpy as np

rng = np.random.default_rng(7)

# The problem: find the cheapest item in a large catalog of M candidates,
# where item i has scalar cost c[i].
M, K = 1_000_000, 6            # items, agents
cost = rng.standard_normal(M)  # the cost of each candidate item

# Centralized solver: one reasoner scans the whole catalog.
central_idx = int(np.argmin(cost))
central_val = float(cost[central_idx])

# Distributed problem solving: decompose the catalog into K disjoint parts,
# each agent solves its sub-problem in isolation and returns ONLY a summary
# (its local-best index and value); a recombiner selects the global winner.
parts = np.array_split(np.arange(M), K)
local_best = []                                  # one summary per agent
for a, idxs in enumerate(parts):
    sub = cost[idxs]
    j = int(np.argmin(sub))                      # agent solves its sub-problem
    local_best.append((int(idxs[j]), float(sub[j]), len(idxs)))

# Recombination: the coordinator compares K summaries, not M items.
winner = min(local_best, key=lambda t: t[1])
dist_idx, dist_val = winner[0], winner[1]

print("items M                 :", M)
print("agents K                :", K)
print("items the coordinator saw:", K, "(local summaries, not", M, ")")
print("centralized argmin index:", central_idx)
print("distributed argmin index:", dist_idx)
print("answers identical?      :", central_idx == dist_idx and central_val == dist_val)
print("centralized min value   :", f"{central_val:.6f}")
print("distributed min value   :", f"{dist_val:.6f}")

items M                 : 1000000
agents K                : 6
items the coordinator saw: 6 (local summaries, not 1000000 )
centralized argmin index: 334838
distributed argmin index: 334838
answers identical?      : True
centralized min value   : -4.586801
distributed min value   : -4.586801

The two solvers return the identical item, 334838, and the coordinator reached that answer by comparing six summaries instead of a million costs. This is distributed problem solving in miniature: a single goal, decomposed into independent sub-problems, recombined by an operation that touches only the per-agent results. It is exact here for the same structural reason data parallelism was exact in Code 1.1.1, because $\min$ over a partition equals the partitioned $\min$, just as a sum over a partition equals the partitioned sum. The branch gets hard, as Section 27.2 shows, precisely when the sub-problems are not independent and an agent's local answer depends on what its neighbors found, which is where coordination protocols earn their keep.

import ray, numpy as np
ray.init()

@ray.remote
def solve_subproblem(cost_shard):          # one agent, runs anywhere in the cluster
    j = int(np.argmin(cost_shard))
    return j, float(cost_shard[j])

shards = np.array_split(cost, K)
futures = [solve_subproblem.remote(s) for s in shards]   # K agents dispatched
local_best = ray.get(futures)                            # collect K summaries
winner = min(local_best, key=lambda t: t[1])             # recombination step

5. Why the Classical Foundations Matter Now Advanced

For two decades DAI was a respected but somewhat quiet field, because building an agent that could reason flexibly about an open world was itself unsolved; multi-agent theory was elegant but the agents themselves were brittle. Large language models changed that overnight. An LLM is, for the first time, a general-purpose reasoner you can instantiate many times, give different roles and tools, and let converse. Suddenly the practical bottleneck is no longer the individual agent but the coordination among many, which is precisely the problem DAI spent the 1980s and 1990s formalizing. A modern system of LLM agents that decompose a task, post partial results to shared memory, bid for sub-tasks, and reconcile conflicting conclusions is running the blackboard architecture, the Contract-Net protocol, and distributed belief revision under new names.

This is why a part on multi-agent systems opens with history rather than with the latest framework. The frameworks will change; the underlying problems, who does what, how partial results combine, what to do when agents disagree or vanish, are the same ones DAI named. Chapter 32 builds modern orchestration on these foundations, and the rest of Part VI fills in the theory between here and there. The throughline of the whole book holds at this final axis: agents are distributed components that must communicate and coordinate, so the scale-out concerns reappear, and the classical answers are the place to start.

We now have the part's map: intelligence is the sixth and last axis of distribution, the classical field that studied it is DAI, and DAI splits into distributed problem solving and multi-agent systems. We have seen the smaller branch reproduce a centralized answer exactly, and we have seen why these foundations are suddenly the working vocabulary of modern agent systems. The rest of Chapter 27 develops the distributed-problem-solving branch in depth, beginning with how one problem is decomposed across cooperating solvers in Section 27.2.