In distributed AI, communication is not “dump JSON and hope.” Agents must agree on what words mean (ontology), what counts as a promise (speech acts), and how conversations terminate (protocols). Natural language is flexible but ambiguous; rigid APIs are precise but brittle. Multi-agent failures often look like planning bugs but are really misaligned message semantics — two agents “agreed” in chat without sharing ground truth. This chapter frames classical ideas that still apply when LLMs are the medium.

Message passing sends copies of information; agents are loosely coupled and failures are often localized. Shared memory / blackboards offer fast reads but need locks, schemas, and conflict rules. Hybrid systems pass events while persisting canonical records (e.g., ticket IDs, versioned documents). LLM stacks frequently fake shared state by stuffing everything into one context window — that does not scale and erases provenance. Prefer explicit handles (URLs, record IDs) in messages over giant blobs.

Following work in the philosophy of language (Austin, Searle) and agent communication languages, treat utterances as actions: inform (assert a fact), request (ask another to act), commit (obligate future behavior). Agents reason about felicity conditions — is the speaker authorized to commit? Is the proposition grounded? LLM outputs often sound like commitments; engineering requires binding commits to tool calls, tickets, or signed tokens.

Historically, agent communication languages (e.g., FIPA ACL) paired a communicative act (performatives like request, inform, cfp) with a content expression in a content language. Implementations today may use JSON or protobuf with an explicit illocution field. The lesson: receivers should branch on act type, not only parse payload keys. That enables policy hooks (“reject unsigned commit”) and testable state machines.

An ontology fixes the meaning of predicates and objects (Order, Shipped, RefundEligible). Without it, two agents may use the same word for different concepts. Content languages (logic-based or JSON-schema-based) make messages machine-checkable. For LLM agents, pair natural language with a canonical schema the model must fill: slots, enums, units. Validate with parsers; never trust free-form alone for money-moving actions.

A protocol specifies legal message sequences: who may speak, retries, timeouts, and terminal states. Auction phases, two-phase commit, and HTTP all follow this pattern. For LLM multi-agent chats, add max rounds, summarization checkpoints, and explicit DONE or ESCALATE transitions. Without termination rules, systems oscillate or burn tokens forever. Draw the protocol; then implement guards in code, not only in prompts.

Using raw natural language as the only interchange is seductive and dangerous. Models hallucinate structure, drop constraints, and reinterpret performatives. Mitigations: structured outputs, tool schemas, automatic validation, repair loops (reject → rewrite), and keeping prose as a human-facing view over canonical records. Monitor parse failure rates and semantic disagreements as first-class metrics.

Inventory your acts, schemas, and protocols. For each agent pair, document initiator/responder, SLAs, and failure branches. Next chapter: once messages work, how do agents coordinate tasks without tripping over each other?