Multi-Agent Systems: Coordination, Communication, and Strategic Interaction

Every page in this module so far has treated an agent as a single thing reasoning about a world. Almost every real deployment involves more than one. This page covers how separate agents actually exchange information and coordinate action, since "communication" turns out to name several genuinely different mechanisms rather than one thing done in different programming languages.

Direct signals

The simplest mechanism is a direct, addressed message from one agent to another — a synchronous call, an asynchronous notification, a socket connection. This site's own PatLang material documents a real, working implementation: named agents claim a port, declare handlers for specific message types, and query or notify each other directly by address. The strength of direct signalling is precision — you know exactly who you're talking to and when the message arrived. The weakness is coupling: sender and receiver both need to know the other exists, which becomes brittle as the number of agents grows.

Shared resources and stigmergy

An entirely different mechanism avoids addressed messages altogether: agents coordinate by modifying a shared environment and reading each other's modifications, with no direct channel between them at all. This has a real biological name and origin. Grassé coined stigmergy studying termite nest construction: a termite deposits a pheromone-marked pellet, the pellet's presence stimulates a neighbour to deposit another nearby, and complex structure emerges with no termite ever directing another1. Later work distinguishes two forms of this: sematectonic stigmergy, where the structure itself is the stimulus, and marker-based stigmergy, where a separate signal — a scent trail, deliberately — carries the coordinating information on top of the structure. Ant and termite pheromone trails are specifically the marker-based case: the trail is not the nest, it's a message layered onto the environment for others to read.

This directly inspired a real class of software algorithms. Dorigo's Ant Colony Optimization uses artificial pheromone trails on a graph, reinforced by positive feedback and weakened by evaporation, to solve combinatorial search problems no single ant-like agent could solve alone2. In distributed computing more generally, Gelernter's Linda coordination language formalised the same idea decades ago as a tuple space: a shared associative memory where any process can deposit or read data without knowing which other process put it there or will read it next3. A shared database table, a blackboard architecture, or a shared configuration store in a modern multi-agent system are all doing the same job: coordination through a shared resource, not a direct channel.

Message queues and the enterprise service bus

Between a direct, addressed signal and a fully shared resource sits asynchronous message queuing: a producer publishes a message to a named channel without knowing which consumer, if any, will process it, and consumers subscribe to channels they care about. This decouples the two sides in time as well as address — the producer doesn't need the consumer to be running when the message is sent. PatLang's own queue module (queue_publish/queue_consume/queue_ack) implements exactly this pattern in a durable, disk-backed form, and the same idea at enterprise scale is what an Enterprise Service Bus provides: a shared, managed channel that many otherwise-unrelated systems publish to and subscribe from, without any of them needing direct knowledge of the others.

Formal agent communication languages

Classical multi-agent systems research took a different, more linguistically ambitious approach: standardising what an agent could mean by a message, not just how it gets delivered. KQML and its successor FIPA-ACL define a fixed set of performatives — inform, request, propose, accept-proposal, and others — built on speech act theory's observation that an utterance can itself be an action, not just a description of one4. Saying "I propose X" doesn't describe a proposal, it performs one. A formal agent communication language forces every message into one of these performative categories, which makes an agent's intent machine-checkable in a way an unstructured natural-language message isn't.

Task allocation as its own protocol

Communication mechanism and coordination protocol are separate concerns, and Smith's Contract Net Protocol is the classic example of a protocol built on top of whichever transport is underneath it5. An agent with a task it can't or doesn't want to do broadcasts an announcement; other agents bid based on their own capability and current load; the announcer awards the contract to whichever bid it prefers. This works identically whether the announcement travels as a direct signal, a shared-resource posting, or a message-queue publication — it's a coordination pattern, not a wire protocol.

Coordination without any communication at all

The final mechanism involves no channel, shared resource, or protocol whatsoever. Reynolds' boids model produces convincing flocking behaviour from three purely local rules — stay near your neighbours, avoid collisions, match their heading — with each simulated bird reacting only to what it can directly observe of nearby birds, never exchanging a message6. This site's own material on Game AI covers the same steering-behaviour family in more depth. The coordination here is entirely implicit: each agent's own locally-observed behaviour is the only signal any other agent receives.

Choosing a mechanism is choosing a set of failure modes

None of these six is a strictly better choice than the others — each trades a specific vulnerability for a specific strength, and the choice should be made deliberately. Direct signals are precise but tightly coupled. Shared resources and message queues both decouple agents but introduce a real risk this site's material on assumption-based planning would recognise immediately: an agent reading a shared resource is trusting an assumption about what a different piece of code intended when it wrote there, with no message ever explicitly confirming that intent. Formal communication languages make intent explicit at the cost of expressive flexibility. Contract Net assumes agents bid honestly, which is exactly the kind of assumption worth stress-testing with the saboteur mindset this site's requirements-engineering material argues for. And implicit coordination through observation alone has no mechanism at all for correcting a wrong shared assumption once one takes hold, because there was never an explicit claim to check in the first place.

Where this connects

References

  1. Grassé, P.-P. (1959). La reconstruction du nid et les coordinations interindividuelles chez Bellicositermes natalensis et Cubitermes sp. La théorie de la stigmergie. Insectes Sociaux, 6(1), 41–80. ↩

  2. Dorigo, M., & Stützle, T. (2004). Ant Colony Optimization. MIT Press. ↩

  3. Gelernter, D. (1985). Generative communication in Linda. ACM Transactions on Programming Languages and Systems, 7(1), 80–112. https://doi.org/10.1145/2363.2433 ↩

  4. Searle, J. R. (1969). Speech Acts: An Essay in the Philosophy of Language. Cambridge University Press. ↩

  5. Smith, R. G. (1980). The contract net protocol: High-level communication and control in a distributed problem solver. IEEE Transactions on Computers, C-29(12), 1104–1113. ↩

  6. Reynolds, C. W. (1987). Flocks, herds, and schools: A distributed behavioral model. Computer Graphics (ACM SIGGRAPH '87 Conference Proceedings), 21(4), 25–34. ↩