%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#E8ECFF", "primaryBorderColor": "#4054B2", "primaryTextColor": "#16171B", "lineColor": "#3B4351", "edgeLabelBackground": "#FAF7F0", "clusterBkg": "#EFE9DC", "clusterBorder": "#766F65"}, "flowchart": {"rankSpacing": 30, "nodeSpacing": 42}}}%%
flowchart TB
S(["Source"]) -->|"message"| E["Encoder"]
E -->|"signal"| C["Channel"]
N["Noise"] --> C
C -->|"received signal"| D["Decoder"]
D -->|"message"| R(["Destination"])
R -.->|"Level A ends here"| W["meaning reconstruction ---<br/>beyond Level A"]
classDef risk fill:#F4D7D5,stroke:#A4161A,color:#16171B
classDef world fill:#EFE9DC,stroke:#766F65,color:#16171B
class N risk
class W world
8 Speaking in Tongues: Agent Communication, Then and Now
Part II ended by admitting a second agent into the room, and with it a difficulty the first never had: the two must somehow reach each other. An agent that thinks, acts, and remembers in perfect isolation is, to any other agent, a sealed box — whatever it knows or intends or has just decided stays locked inside it until it is said. Communication is the first faculty a plurality requires, before cooperation, before coordination, before conflict, none of which can so much as begin until one agent can get something across to another. And getting something across, this chapter is at pains to show, is a great deal more than getting a string across. The title is only half a joke: a roomful of agents, each fluent and none quite certain the others mean what they appear to, is a modern Babel with better uptime.
None of which is new. Communication is among the most thoroughly theorised activities there is, from three directions that rarely speak to one another. Philosophers of language asked what we do when we speak — Austin and Searle’s discovery that to say a thing is often to perform an act, and Grice’s account of how a listener extracts far more than the words contain. Engineers asked how to push a message through a noisy medium without losing it — Shannon’s information theory, which solved that problem so completely that it could afford to throw meaning away as beneath its notice. And artificial intelligence, in its first agent era, tried to weld the two together into languages by which independently built programs might exchange not merely bytes but intentions — KQML, FIPA-ACL, and the speech-act machinery beneath them. The modern agent, chattering to its fellows in fluent English over a freshly minted protocol, is re-enacting all three traditions at once, mostly without knowing it.
The governing distinction of the chapter is the one the preface promised: between exchanging strings and achieving mutual understanding. The first is essentially solved — two agents can shuttle messages as cheaply and reliably as two processes share a socket, and the modern protocol landscape is, at bottom, plumbing of exactly that kind. The second is not solved, has never been solved, and is not the sort of thing a better wire format will solve. For a message to land — to mean to its receiver what its sender meant by it — the two must already share a great deal that no message carries: a vocabulary, a context, a grip on the same world, and some assurance that the speaker is not simply lying. Everything hard about agent communication lives in that gap, and the gap is where this chapter spends its time.
We proceed from the act, to the medium, to the meaning. We look first at communication as a species of action — saying as doing — then at the channel that carries it and the surprising little it guarantees; at the classical agent communication languages that tried to standardise intention itself; at the trio of difficulties — grounding, ambiguity, and deception — that pry the strings apart from the understanding; at natural language, the gloriously expressive and dangerously slippery lingua franca the foundation-model era has settled on; and last at the modern protocols, the old languages rediscovered under newer and better-funded names. What communication builds — the shared knowledge and common ground two agents come to stand on — is the business of Chapter 9; the protocol engineering in depth is Chapter 22; and whether agents might learn to communicate rather than be taught is Chapter 17. This chapter is about the speaking itself.
8.1 Saying Is Doing
Section 6.1 gave the agent a body: sensors to perceive and actuators to act, the model deciding and the harness carrying the decision out into the world. Communication is that same loop turned to face another agent. When the thing in the environment worth acting on is another mind, the actuator of choice is language — and the discovery that founds the subject, made not by engineers but by philosophers, is that language used this way is not a means of describing the world but a means of acting on it. To say the right thing in the right place is to do something: to commit, to oblige, to inform, to decide. Communication, properly understood, is a species of action, and the theory of it begins there.
The point is owed to J. L. Austin, whose How to Do Things with Words (1962) began by noticing a class of sentences that plainly describe nothing. “I promise to fix the tests”; “I name this ship the Queen Elizabeth”; “I bet you sixpence it will rain”: these report no fact and can be neither true nor false, because uttering them, in the right circumstances, simply is the promising, the naming, the betting. Austin called them performatives and then, characteristically, dissolved his own category — for on inspection every utterance does something, even the flattest assertion, which performs the act of asserting. What survived the dissolution is the distinction that has lasted: between the locutionary act of producing a meaningful sentence, the illocutionary act performed in producing it — promising, asserting, requesting, ordering — and the perlocutionary act of its effect on the hearer, who is thereby persuaded, alarmed, or obeyed. The middle one is the heart of the matter: the illocutionary force of an utterance is the kind of move it makes, and it is a property of the saying, not of the string.
Searle turned the insight into a system and gave the unit its enduring name — the speech act (1969). The same propositional content, “the door is shut”, can be carried by quite different forces: asserted, questioned, ordered (“shut the door”), promised. Force and content come apart, and the force is what tells the hearer what to do with the content. Searle then sorted the forces into a small taxonomy (1975) that an agent-builder will find suspiciously familiar: assertives, which commit the speaker to a truth (“the build is green”); directives, which try to get the hearer to act (“fix the flaky test”); commissives, which commit the speaker to act (“I’ll take the migration”); expressives, which vent an attitude (“thanks”, “sorry”); and declarations, which change the world simply by being said, given the right authority (“the pull request is approved” — and now it is). Five kinds of move; we shall meet them again, barely disguised, as the message types of the agent communication languages in Section 8.3.
| Illocutionary force | What the move does | An agent’s utterance |
|---|---|---|
| Assertives | Commit the speaker to a truth | “the build is green” |
| Directives | Try to get the hearer to act | “fix the flaky test” |
| Commissives | Commit the speaker to act | “I’ll take the migration” |
| Expressives | Vent an attitude | “thanks”, “sorry” |
| Declarations | Change the world simply by being said, given the right authority | “the pull request is approved” |
For a philosophy this is satisfying; for an agent it wants teeth, and artificial intelligence supplied them by treating the speech act as a plan. Cohen and Perrault modelled it as a planning operator in the exact sense of Section 6.2 — a STRIPS-style action with preconditions and effects, save that its effects land on minds rather than on the world (1979). To request has the precondition that the speaker want the thing and the effect that the hearer come to believe they want it; to inform has the precondition that the speaker believe what they say — the sincerity condition, which nothing in the machinery compels an agent to honour — and the effect that the hearer come to believe it too. A speech act, so construed, is an operation on the mental state of another agent, and may be reasoned about, chained, and planned for exactly as a physical action can. Cohen and Levesque later grounded the commissives in a theory of intention as commitment (1990): to promise is to adopt, publicly and bindingly, a persistent goal — which is just why a promise, unlike a wish, is something the other agents may safely build their own plans upon.
The lesson for the agent-builder is the chapter’s first and most easily missed. A message is a move, not a string; its force is part of its meaning, and an agent that reads only the words has read only half. When the orchestrator says “take the migration” it issues a directive that allocates work; when the coder replies “done, tests pass” it makes an assertion the others will act on without re-checking; when the reviewer says “approved” it performs a declaration that changes what may now happen to the branch. Treat any of these as mere text to be scanned for keywords — mistake the promise for a status report, or the approval for an idle comment — and the conversation quietly comes apart, because the agent has registered what was said and missed what was done. All of which presupposes, of course, that the message arrived at all and survived the journey with its sense intact. That humbler matter — the channel, and the surprisingly little it can promise — is where we turn next.
8.2 The Channel and What It Cannot Carry
Set the philosophy aside for a moment and ask the engineer’s question instead: how does a message actually get from one agent to another? The definitive answer is among the most consequential pieces of twentieth-century mathematics. In 1948 Claude Shannon set out a complete theory of communication (1948): a source producing a message, an encoder turning it into a signal, a channel that carries the signal and corrupts it with noise, a decoder at the far end, and a destination. From this spare picture Shannon drew out everything — a precise measure of how much information a source produces, the maximum rate a channel can bear (its capacity), and the remarkable guarantee that, with enough cleverly added redundancy, a message can be pushed across a noisy channel with an error rate as near to zero as one likes. Every digital communication since — every packet, every disk read, every byte one agent sends another — rests on it. Reliable transport is, thanks to Shannon, a solved problem.
It is solved, however, by a manoeuvre that should give the agent-builder pause. Shannon bought his rigour by throwing meaning overboard, and said so on the first page: the “semantic aspects of communication,” he wrote, “are irrelevant to the engineering problem.” His information is not meaning but something closer to its opposite — a measure of uncertainty, of how much a message narrows down what the source might have sent. A string of random characters carries maximal Shannon information and no meaning whatsoever; a heartfelt message you could have recited in advance, word for word, carries almost none. The theory that underwrites the whole of digital communication is, by deliberate construction, wholly indifferent to whether anything is understood. It guarantees that the bits arrive; it has, and wants, nothing to say about what they mean.
Warren Weaver, introducing Shannon’s work to a broader audience, drew the moral exactly (1949). Communication, he observed, poses problems at three levels. Level A is technical: how accurately can the symbols be transmitted? Level B is semantic: how precisely do the transmitted symbols convey the intended meaning? Level C is effectiveness: how well does the received meaning produce the intended conduct? Shannon had despatched Level A so completely that the other two could be set aside — and “later” is the situation this chapter finds itself in. Everything an agent actually needs from communication lives at Levels B and C: that its directive be understood as the directive it was (B), and that the directive in fact get the task done (C). The channel delivers Level A and stops, precisely at the waterline where the interesting difficulties begin.
Part of why this is so easily forgotten is a metaphor lodged in the very way we speak about speaking. We put ideas into words, get them across, extract the meaning from a sentence, complain that a point did not come through — as though meaning were a substance loaded into the container of language, shipped down a pipe, and unpacked intact at the far end. Reddy named this the conduit metaphor and showed how thoroughly it misleads (1979). Meaning is not transmitted; it is reconstructed. The signal that arrives is no more than an instruction to the receiver to build, out of materials it already holds — its vocabulary, its context, its model of the sender — something it hopes resembles what the sender had in mind. Where the receiver lacks the materials, no quantity of signal will supply them; one cannot mend a failure of understanding by improving the pipe. The channel moves tokens; the meaning is made, freshly and fallibly, at the receiving end.
For agents, this rearranges where the difficulty lies. The channel between two agents is nearly free and very nearly perfect: a socket, a message bus, an API call, all of it riding on decades of Shannon’s legacy in checksums and retransmission. Bytes do not go astray between a coder agent and its reviewer; whatever was sent is what arrives. Which means — and here is the spine of the chapter — that essentially none of the difficulty of agent communication lives in the channel. Two agents can exchange flawless gigabytes and understand one another not at all. The easy half of communication, the half Shannon solved, is the half that moves strings; the hard half, left untouched, is everything the string leaves out — the force of Section 8.1, and the meaning the receiver must rebuild without mishap. The classical response was to load more of that burden onto the message itself: to make each string declare, in a fixed and machine-readable form, what kind of act it was and what it concerned, so that the force, at least, might survive the crossing. That is the project of the agent communication languages, and we take it up next.
8.3 Agent Communication Languages
If the channel will not carry the force, the obvious recourse is to put the force in the message. Stamp each string with an explicit, machine-readable mark of what kind of act it is — this is a request, that an assertion, this other a commitment — and a receiving program can recover at least the illocutionary layer without having to divine it from the words. This is the animating idea of the Agent Communication Language (ACL): a standard envelope in which independently built agents, who have never met and share no code, might exchange not merely data but speech acts. The effort grew out of the same 1990s programme we met in Section 7.6 — the DARPA Knowledge Sharing Effort (Neches et al., 1991), whose ambition was that what one system knew, another might use — and it produced, in quick succession, two languages worth knowing.
The first was the Knowledge Query and Manipulation Language (KQML) (Finin et al., 1994). A KQML message is a performative wrapped around a content payload and a handful of parameters: the sender and receiver, the content itself, and — tellingly — two fields naming the language the content is written in and the ontology that fixes what its terms mean. The performatives are Searle’s taxonomy turned into a wire format: tell and deny among the assertives, ask-one and ask-all among the directives, achieve and subscribe directing action rather than answer. An agent receiving (ask-one :content (price IBM) :ontology nyse-stocks) knows, without parsing the content at all, that it has been asked a question and is expected to return one — the force arrives explicitly, exactly as the channel of Section 8.2 could not deliver it. It is a genuinely good idea, and for the orchestrator dispatching a request to a coder, or the coder returning a tell, it is very nearly the right shape.
The second, and the one that became a standard, was the Agent Communication Language of the Foundation for Intelligent Physical Agents — FIPA-ACL (2002), a name whose grandeur the work largely justified. Its twenty-two communicative acts — inform, request, query-if, propose, accept-proposal, cfp (a call for proposals), and the rest — came with something KQML had only gestured at: a formal semantics, each act defined in terms of the participants’ mental states, exactly along the plan-based lines of Section 8.1. To inform an agent of p carries a feasibility precondition — that the sender believe p — and a rational effect — that the receiver come to believe it; request and propose are specified the same way, as operators upon belief and intention. This is Cohen and Perrault’s theory promoted to an international standard: a published, machine-readable account of what each kind of message means, in the only currency that counts, its effect on minds.
And yet the languages are, today, a monument rather than a tool — admired, endlessly cited, and almost never used in earnest. Two faults sank them, and neither was the performatives, which were the easy part: a small vocabulary of message types is exactly the sort of thing committees can agree on. The first fault was the content the performatives wrapped. To agree that a message is an inform settles nothing about whether its two parties mean the same by the terms inside it, and the :ontology field, for all its promise, merely names that problem and hands it on — an IOU for a shared meaning that, as Section 7.6 recounted, no two laboratories could be brought to honour. The second fault was subtler and, in hindsight, fatal: the beautiful mentalistic semantics were unverifiable. Nothing outside an agent can check whether it actually believes what it informs, so the standard, in the last analysis, described the conduct of a perfectly sincere agent and trusted everyone to be one (Wooldridge, 2009). The sincerity condition had been written into the foundations of the standard and quietly assumed away.
None of which is to call the project a failure. The agent communication languages were right about the layer that mattered most — that a message should wear its force openly — and that idea, as Section 8.6 will show, is exactly the one the modern protocols have rediscovered. What they could not supply was the shared meaning beneath the force: the assurance that “inform: IBM is up” means the same thing to the teller and the told. That problem did not die with the languages that exposed it; it merely waited, and it is the subject of the next section.
8.4 Grounding, Ambiguity, and the Problem of Meaning
A message’s force can be made to travel, but its meaning cannot be shipped — only rebuilt at the far end — and the agent communication languages broke on exactly that rock. It is worth asking, then, why shared meaning should be so hard to come by — what, precisely, keeps two agents from meaning the same thing by the same string. Three forces do the work. Two we take here; the third, which is of a different character, waits for Section 8.5.
The first is grounding. We met the symbol-grounding problem (Harnad, 1990) in Section 6.5 as a question about a single agent: how do its internal symbols come to be about anything in the world, rather than merely about other symbols? Set two agents talking and the problem doubles, and turns social. It is no longer enough that each agent’s words be grounded in some world; they must be grounded in the same one. Two agents can share a token down to the byte and not share its referent: the orchestrator’s “the staging database” and the coder’s “the staging database” may denote different machines, and one agent’s “done” may mean “the code is written” where the other’s means “the tests pass”. This is the quietly dangerous case, worse than plain gibberish, because it fails silently: a mismatched referent raises no error and trips no exception, so both parties believe themselves understood, build confidently on the misunderstanding, and discover the divergence only later, downstream, wearing the costume of a bug. You cannot read a referent off a word, and an agent that assumes its terms land where it intended has staked the collaboration on a guess.
The second force is ambiguity, and natural language is not merely prone to it but very nearly built from it. One string admits many readings — lexical (“restart the server” — which server?), structural, referential (it, that one, the other), and scopal — and the candidate meanings multiply faster than any sender pauses to count. What settles a reading is never the string alone but the context the receiver brings, which is the meaning-rebuilt-at-the-far-end of Section 8.2 seen at close range. When sender and receiver share that context, ambiguity dissolves so smoothly that neither notices it was there; when they do not, it resolves anyway — to the wrong reading — and, exactly like a grounding mismatch, it resolves without complaint. The orchestrator that says “update the tests” may mean “make them pass” while the coder hears “add new ones”; nothing in the sentence decides between them, and nothing announces that the wrong branch was taken.
Different as they are, grounding and ambiguity point at one and the same missing ingredient: an agreed mapping from words to things, held in common by both parties. Fix that mapping in advance, explicitly and exhaustively, and you have the ontologies and knowledge graphs of Section 7.6 — the structured-knowledge programme seen now from the communicative side, and the thing the ACL :ontology field could only gesture at. But shared meaning need not be carved in stone before the conversation begins; it can be built as the conversation goes — each party checking that it was understood, repairing the mismatches it catches, and banking what both now treat as settled. That growing stock of the mutually taken-for-granted is common ground, and it is so central to communication, and so intricate, that it has the next chapter to itself.
Both forces, note, are failures of meaning to arrive: the sender means something definite and the receiver, lacking the shared mapping, reconstructs something else. The third force is not like that at all. It is the case in which the meaning arrives perfectly and is yet false to the sender’s own mind — the agent that says what it does not believe. Deception, and the endlessly ambiguous medium in which modern agents have chosen to risk it, are where we turn next.
| Force | The missing ingredient | Where it breaks (running example) | Nature of the failure |
|---|---|---|---|
| Grounding | Words grounded in the same world, not merely in some world — an agreed mapping from words to things | “the staging database” denotes different machines; one agent’s “done” means “the code is written”, the other’s means “the tests pass” | Meaning fails to arrive — the receiver rebuilds the wrong referent, and does so silently |
| Ambiguity | A shared context to fix one reading among the many a string admits | “update the tests” — the sender means “make them pass” while the receiver hears “add new ones” | Meaning fails to arrive — it resolves to the wrong reading, without complaint |
| Deception | The speaker’s good faith — the sincerity condition nothing in the machinery compels | An agent that says what it does not believe (taken up in Section 8.5) | Meaning arrives perfectly, yet is false to the sender’s own mind |
8.5 Natural Language, Pragmatics, and Deception
The agent communication languages assumed that agents would meet in the middle, at a formal vocabulary neither side spoke natively. The foundation-model era simply dispensed with the meeting. Its agents are language models, and language — ordinary, unformatted, human language — is the one thing they do without being asked; so they talk to one another exactly as they talk to us, in fluent English, or Python, or whatever the moment calls for, and the elaborate performative envelopes of Section 8.3 fall away as the solution to a problem these agents no longer have. The gain is enormous and immediate. Natural language is the most expressive medium there is, able to carry nuance, hedging, conditionals, and whole arguments that no fixed schema of message types could hold; it is, to communication, what the open-ended computer of Section 6.4 was to action — the universal surface, able in principle to express anything. And it arrives, naturally, towing every difficulty Section 8.4 catalogued, now at full strength: ambiguity in every line, and grounding left to whatever the two models happen to share.
That communication survives this at all is owed to something the formalists underplayed: hearers do not merely decode, they infer. The point is Grice’s (1975). Conversation, he argued, runs on a tacit cooperative principle — contribute what is required, when it is required, for the accepted purpose of the exchange — elaborated into maxims of quantity, quality, relation, and manner: say enough but no more, say what you believe true, be relevant, be clear. The maxims earn their keep where they appear to be broken. Ask a coder agent “is the deploy finished?” and receive “the integration tests are still running”, and you grasp at once that the answer is no — though no no was uttered — because you credit the speaker with being relevant, and relevance supplies the rest. This is implicature: the speaker means more than is said and trusts the hearer to recover it. For agents it is not an ornament but load-bearing structure — an agent deaf to what is implied will misread half of what it is told, and an agent that cannot imply will be tediously, unusably literal.
But notice the load the whole edifice rests on. Grice’s principle is cooperative, and his maxim of quality is do not say what you believe false. The entire machinery by which a hearer recovers more than the words assumes a speaker playing the same game in good faith — and nothing whatever enforces that assumption. It is the sincerity condition once more — good faith presumed everywhere by the cooperative principle and, just as in FIPA-ACL, guaranteed nowhere. Lift the presumption of good faith and the third force of Section 8.4 steps forward: deception. A channel that can carry a belief can carry a false one with equal ease, and a model fluent enough to be persuasive is, by that very fluency, fluent enough to mislead.
What makes this genuinely hard, rather than merely regrettable, is that deception in an agent wears at least three faces and the receiver cannot tell them apart. There is the falsehood by design: an agent instructed, or having reasoned itself, into saying what it knows to be untrue. There is the falsehood by sycophancy, subtler and now well documented (Sharma et al., 2023): a model that has learnt to tell its interlocutor what it infers they want to hear, trading truth for approval. And there is the falsehood by confident error, which is not strictly a lie at all but Frankfurt’s bullshit in the exact technical sense (2005) — speech produced with no regard, one way or the other, for whether it is true; the native register of a model that has met the hazard of hallucination (Section 3.3) and sailed serenely past it. The liar at least knows the truth and troubles to hide it; the bullshitter has abandoned it as a reference point.
To the receiver, all three arrive identically: a fluent, confident, well-formed assertion that happens to be false. A lie, a flattery, and an honest blunder come in the same envelope and the same unwavering prose, and nothing on the outside lets you steam it open. Which is just why the standing caution of this book lands hardest on communication. The coder’s cheerful “tests pass” is exactly the assertion Section 8.1 said the others would act on without re-checking — and must not, because the message cannot certify itself, and only the world beyond it can.
Step back, and the shape is familiar. Natural language bought its expressiveness at the price of its reliability, which is the expressiveness-against-controllability trade-off of Section 6.3 in linguistic dress: the agent communication languages were precise and brittle, natural language is supple and slippery, and there is no third option that is quietly both. The discipline the trade-off recommends is the same here as there — constrain the channel where correctness must be guaranteed (a typed result, a schema, a number the agent cannot fudge), and spend natural language’s freedom only where its expressiveness earns it. Pressed harder, the discipline becomes the book’s standing question, asked now of the channel itself: the cheapest reliable conversation between two agents is frequently no conversation at all. A typed call that returns a schema’d result spends no tokens on pleasantries, cannot be sycophantic, and cannot be misread; natural language between agents is a cost — in budget and in trust — to be paid only where its expressiveness genuinely earns its keep.
Doing that at scale, among many independently built agents, takes more than good intentions: it takes plumbing — a way to discover who is out there, to type what passes between them, to say who is speaking and whether they may be believed. That plumbing is the protocols, which quietly hand back some of the structure natural language threw away, and they are the last of this chapter’s subjects.
8.6 Protocols, Old and New
Which brings us, at last, to the protocols, and to the claim the preface made and this chapter has been quietly assembling the evidence for: that the modern agent protocols are the agent communication languages of Section 8.3, rediscovered. The Model Context Protocol (MCP) and the Agent-to-Agent (A2A) protocol, with their lengthening train of kin, are not a break from KQML and FIPA-ACL but the same project, resumed thirty years on — descendants in substance rather than by documented descent, for nobody at the modern standards meetings was consulting FIPA’s archives, and the rediscovery is independent, which is precisely what makes it evidence: handed the same problem, the industry re-derived the classical answer, this time with more compute, more adoption, and, for once, the funding and the shared governance to make a standard actually take.
Read the new protocols against the old languages and the family resemblance is unmistakable. The agent communication languages needed a way for strangers to find one another and learn what each could do; FIPA called it a directory facilitator, and A2A (2025) calls it an Agent Card — a machine-readable advertisement, published at a well-known address, of an agent’s name, its skills, and its terms of engagement. The old languages needed each message to declare its force; the performative of Section 8.3 returns as the typed method and the structured task, the envelope that still says “this is a request”, “that is a result”. They needed to thread a single conversation through many messages; the reply-with and in-reply-to of KQML return as sessions, task identifiers, and managed context. MCP (Anthropic, 2024), which faces the tool rather than the peer (Section 6.2), tells the same story one altitude down. The performative, the directory, and the conversation are all back, rebranded and far better funded than the first time round.
Yet it would be a poor history that saw only the repetition. Three things are genuinely new, and the most consequential is the one that dissolves the rock the old languages broke on. The content the performatives wrap is no longer a formal logic demanding a shared ontology nobody would ratify; it is natural language (Section 8.5), and the endpoints reading it are foundation models that can, within limits, simply understand it. The interoperability the Knowledge Sharing Effort tried to legislate, the new agents largely improvise, because the hard part the ACLs delegated to an agreed ontology is now done — imperfectly but serviceably — inside the model itself. What dissolved, note, is the ratification problem: no committee need agree an ontology before two strangers can trade sentences. Semantic agreement itself has not been won but relocated — it now lives inside the endpoints, where its failures are the silent kind Section 8.5 priced: two agents, both schema-valid, each resolving the same string to a different reading, and no error raised anywhere. The second novelty is scale and stakes: not a handful of research agents trading toy assertions, but a sprawling, open population acting on real systems with real consequences (Section 6.6), which is why identity, authentication, and delegation — who is speaking, on whose authority, and whether they may be believed — move from afterthought to foundation, answering at the level of plumbing the question the previous section could only raise. The third is governance: the protocols are settling under neutral, shared stewardship rather than any single laboratory’s roadmap, which is exactly the condition the agent communication languages never enjoyed, and for want of which, as much as anything, they failed to take.
All of this is communication by design: humans specify the protocol, the agents obey it. There is also a communication by evolution. In the learning tradition, agents are not handed a protocol but left to discover one — to learn from experience what to signal, when, and how to read what they receive — so that a communication system emerges from the training rather than from the standards committee (Foerster et al., 2016). The two are the same question approached from opposite ends, and the learned end has its own unsettling rediscoveries: agents trained to communicate can, under misaligned incentives, learn to communicate adversarially — to deceive (Blumenkamp & Prorok, 2020) — which is the third face of falsehood arriving by gradient descent rather than by design. This emergent communication is the learned twin of the designed protocols, and Chapter 17 gives it the attention it deserves.
Two debts remain, and the chapter discharges them by pointing. The engineering of these protocols in earnest — schemas and capability discovery, identity and authentication, delegation, lifecycle, and the cross-framework plumbing that lets independently built systems actually interoperate — is the business of Chapter 22, which treats them as interfaces between systems rather than as solvents for architectural disagreement. The larger debt is the one the whole chapter has been circling. A protocol, however elegant and however well governed, delivers Level A of Section 8.2 flawlessly and a useful slice of Level B; it moves typed strings between agents with perfect fidelity. It does not, and cannot, manufacture the understanding those strings are meant to carry. Exchanging messages was always the easy half, and the protocols are its triumph; achieving mutual understanding is the hard half, and it rests on something no wire format contains — the shared knowledge, belief, and common ground on which two minds must stand before they can be said to communicate at all. That is where Part III turns next.
8.7 Summary
- Communication is action, not transport. A message is a move — a request, a commitment, an assertion — with consequences the receiver must reckon with; the speech-act tradition of Austin and Searle is the right lens, and an agent that hears only strings has misheard.
- The channel is the easy half. Shannon’s information theory made reliable transport a solved problem by setting meaning deliberately aside; for agents the channel is nearly free, which is exactly why none of the hard part lives there. Moving strings is not conveying sense.
- The agent communication languages standardised intention. KQML and FIPA-ACL wrapped a payload in a performative — a machine-readable mark of what the message was for — and foundered not on the performatives but on the shared ontology the content still required. Their problem outlived them.
- Understanding asks for more than the message contains. Grounding (shared words tied to the same world), ambiguity (one string, many meanings), and deception (a string need not reflect a belief) are the three forces that separate exchanging strings from achieving mutual understanding.
- Natural language is the new lingua franca, for better and for worse. The foundation-model era lets agents simply talk, gaining an unmatched expressiveness and inheriting every ambiguity, implicature, and opportunity for deception that natural language has always carried; Grice’s pragmatics becomes engineering.
- Modern protocols are the old languages rediscovered. MCP, A2A, and their kin re-derive the performatives, discovery, and delegation of the classical ACLs under new names — the depth deferred to Chapter 22, the learned twin to Chapter 17, and the mutual understanding no protocol can guarantee to Chapter 9.
8.8 Exercises
Exercise 1. A tester agent ends every run with exactly one of four messages, whose long-run frequencies are “pass” 0.9, “fail” 0.06, “flaky” 0.03, and “timeout” 0.01. The entropy of a source that emits message x with probability \Pr(x) is, in bits,
H \;=\; -\sum_{x} \Pr(x) \log_2 \Pr(x),
and no uniquely decodable binary code can achieve an expected codeword length below H. (a) Compute H for this tester, and for a hypothetical tester whose four messages are equally likely. (b) Design a prefix-free binary code for the four messages — no codeword a prefix of another — whose expected length beats the two-bit fixed-length encoding; compute that expected length and confirm it lies between H and 2 bits. (c) A heartbeat agent emits “ok” every minute without fail. Compute the entropy of its message source; then say where the operational usefulness of a heartbeat resides, given that each “ok” carries zero information in Shannon’s sense, and what the example shows about the distance between Shannon information and meaning.
Exercise 2. Over one run, the team exchanges 250 messages. Transport is Shannon-grade: each transmission is corrupted with probability 10^{-2}; every corruption is caught by a checksum and the message resent, resends independent and corrupted with the same probability; and a delivered message harbours an undetected corruption with probability 10^{-9}. Independently of transport, each delivered message is silently misread — resolved to the wrong referent or reading, with no error raised — with probability 0.015. (a) Compute the expected number of transmissions per delivered message, and hence the expected number of extra sends per run that reliable transport costs. (b) Compute the expected number of undetected corruptions per run, the expected number of misreadings per run, and the ratio between them. (c) Compute the probability that a run contains at least one misreading, and the expected number of runs between undetected corruptions. (d) Assign each failure mode to one of Weaver’s levels, and explain which of the two Shannon’s machinery could suppress still further — and why the other is beyond its reach in principle, however good the code.
Exercise 3. A colleague proposes to recover the illocutionary force of the team’s messages with the following classifier:
def classify_force(message: str) -> str:
text = message.lower()
if text.endswith("?"):
return "directive" # a question asks for an answer
if "i'll" in text or "i will" in text:
return "commissive"
if "thanks" in text or "sorry" in text:
return "expressive"
if "approved" in text or "merged" in text:
return "declaration"
return "assertive"- Construct five utterances, each plausible in the mouth of an orchestrator, coder, reviewer, or tester, such that each of Searle’s five forces is the true force of exactly one utterance and the classifier mislabels all five; for each, give the true force, the label assigned, and the rule that fired. (b) Using the distinction between the locutionary and the illocutionary act, explain why these failures are principled rather than patchable — why no classifier reading the string alone can be right in general, however many cues it accumulates — and why declarations are the worst case. (c) State what further inputs a competent force-recogniser would need, explain why the languages of Section 8.3 chose instead to carry the force in an explicit envelope field, and name the part of the problem that choice still leaves unverified.
Exercise 4. One line of a task brief admits m mutually exclusive readings. The sender’s intended reading is drawn from a distribution p = (p_1, \dots, p_m); the receiver, independently, resolves the line to reading j with probability q_j. Call the exchange silently successful when the two readings coincide — and note that nothing announces the other case. (a) Show that the probability of silent success is \sum_{i=1}^{m} p_i q_i. (b) Evaluate it for a shared context, p = q = (0.7, 0.2, 0.1), and for a mismatched one, p = (0.7, 0.2, 0.1) against q = (0.1, 0.2, 0.7). (c) Let the receiver instead resolve deterministically to its likeliest reading (the largest q_j); recompute both cases and say what determinism amplifies. (d) A brief contains k = 4 such lines, resolved independently; compute, for each of the four regimes of (b) and (c), the probability that the whole brief lands as intended. (e) Prove that for a shared context (q = p) the silent-success probability \sum_i p_i^2 is at least 1/m, with equality exactly when p is uniform, and interpret the inequality: what does sharing context do to p, and hence to understanding?
Exercise 5. The orchestrator’s brief tells the coder to run a migration against “the staging database”, a phrase the coder can bind to either of two machines. Acting on the wrong binding costs R = 30{,}000 tokens of downstream rework; one round of clarification — question and answer — costs c = 400 tokens and settles the referent for certain. (a) The coder’s confidence in its preferred binding is p = 0.8: compare the expected cost of acting at once with the cost of asking first, and decide. (b) Derive the confidence threshold p^* above which acting at once is the cheaper policy, and evaluate it. (c) A longer brief carries six referent-bearing terms, with confidences 0.99, 0.98, 0.95, 0.90, 0.85, 0.80, each mismatch costing R independently and additively; compute the expected total cost of asking about nothing, of asking about everything, and of the optimal selective policy. (d) Suppose now that a clarification answer is itself misread with probability 0.05, so asking buys correctness 0.95 rather than certainty. Rederive the threshold, restate the optimal selective policy, and recompute the three costs. What does the fallibility of repair do to the economics of grounding?
Exercise 6. For each of the four exchanges below, give (i) what the reply literally asserts, (ii) the implicature its hearer will draw, (iii) the Gricean maxim whose presumed observance licenses the inference, and (iv) how a speaker not observing the maxims could exploit or defeat precisely that inference, and which face of falsehood from Section 8.5 such a speaker instantiates. (a) Orchestrator: “will the migration be done by the four-o’clock build?” — Coder: “the schema turned out to have forty-one tables.” (b) Orchestrator: “is the branch ready to merge?” — Reviewer: “the tests pass.” (c) Orchestrator: “anything I should know before we release?” — Tester: “the payment suite passed on the third attempt.” (d) Coder: “is the retry logic acceptable?” — Reviewer: “it is certainly an original approach.” (e) Finally, rewrite exchange (b) as a typed status object, choosing the fields yourself; determine which of the reply’s implicatures survive the rewriting, and explain why a schema’s silence differs in kind from a speaker’s silence.
Exercise 7. Following Cohen and Perrault, model the team’s talk as operators on mental-state atoms, writing B_i \varphi for “agent i believes \varphi” and \mathrm{Goal}_i(\varphi) for “agent i has the goal that \varphi”, with \varphi here the proposition that the flaky test is fixed. The speech act request(i, j, \varphi) has precondition \mathrm{Goal}_i(\varphi) and effect B_j(\mathrm{Goal}_i(\varphi)); inform(i, j, \varphi) has precondition B_i \varphi — the sincerity condition — and effect B_j \varphi. Two internal, non-communicative steps complete the vocabulary: adopt, by which a cooperative j holding B_j(\mathrm{Goal}_i(\varphi)) acquires \mathrm{Goal}_j(\varphi), and work(j), which requires \mathrm{Goal}_j(\varphi) and makes \varphi true along with B_j \varphi. The orchestrator o starts with \mathrm{Goal}_o(\varphi) and the coder c with nothing. (a) Exhibit the shortest sequence of steps ending in B_o \varphi, giving the full atom set after each step and checking each precondition. (b) Construct a second run whose message trace — the speech acts alone, which are all o observes — is identical to (a)’s, but in which inform’s precondition is false; conclude precisely why a semantics stated in terms of private mental states cannot be verified by any observer of the trace. (c) Implement the progression: atoms as strings, an operator as preconditions plus effects, and a checker that applies a plan to a state, verifying at each step either every precondition (an omniscient auditor) or only the atoms belonging to a named observer, who takes the rest on trust. Use it to validate (a) and to demonstrate (b) mechanically. (d) What single addition to the exchange lets o distinguish the two runs after all — and what does the answer imply about where trust in an inform must be anchored?
Exercise 8. Equip the orchestrator and coder with a task-assignment protocol over the performatives request, agree, refuse, inform-done, inform-failed, and cancel: a conversation opens with request; the coder answers agree or refuse, and refuse closes the conversation; after agree the coder eventually sends exactly one of inform-done or inform-failed, which closes it; the orchestrator may send cancel at any point after request and before the close, which also closes it; and nothing follows a closed conversation. (a) Specify the protocol as a finite-state machine: states, alphabet, transition table, initial state, and accepting states, counting a conversation as valid only when complete. (b) Implement a validator check(trace) over lists of performative names and run it on the six traces [“request”, “agree”, “inform-done”], [“request”, “inform-done”], [“request”, “agree”, “inform-done”, “inform-failed”], [“request”, “refuse”], [“request”, “agree”, “cancel”], and [“request”, “agree”]. (c) For the first trace — accepted — construct three scenarios, one per force in Table 8.2, in which the conversation is protocol-perfect and the communication fails anyway. What exactly does protocol conformance certify, and what does it leave uncertified?
Exercise 9. Redesign the team’s message fabric under the discipline of Section 8.5: constrain the channel where correctness must be guaranteed, and spend natural language only where its expressiveness earns its keep. The recurring exchanges are (1) orchestrator to coder, task assignment; (2) coder to orchestrator, progress report; (3) tester to all, test outcome; (4) reviewer to orchestrator, verdict on a branch; (5) coder to orchestrator, clarification question and answer; and (6) coder to reviewer, rationale for a design decision. (a) For each exchange choose a typed schema, natural language, or a hybrid, sketching the fields of every schema you introduce, and honour three constraints: an assertion that other agents will act on without re-checking must be produced by machinery or be independently verifiable, and you must say which field and produced by what; a declaration must carry its authority, and you must say who may set the field and what enforces that; and every retention of natural language must state what its expressiveness is buying. (b) Audit the design against the three faces of falsehood: for each face, point to the element that neutralises it or name the exchange in which it survives. (c) Name the residual risk no such design can remove, and place it on Weaver’s ladder.
Exercise 10 (lab). Estimate empirically the reading distributions that Exercise 4 assumed. Choose a one-line instruction from the team’s domain that is genuinely ambiguous — “update the tests for the parser” will do — and two context conditions: X, a short preamble establishing that continuous integration has been failing all morning, and Y, one establishing that a coverage target has just been raised. Fix a classification rubric before sampling: the distinct readings you will recognise (say, make the failing tests pass, add new tests, modernise the test style) and a written rule for assigning a response to one. For each condition, sample a model at least thirty times at non-zero temperature, asking for a one-line statement of what it would concretely do; classify every response; and report the empirical distributions \hat{p}_X and \hat{p}_Y. Compute the within-context agreements \sum_i \hat{p}_{X,i}^2 and \sum_i \hat{p}_{Y,i}^2 and the cross-context agreement \sum_i \hat{p}_{X,i} \hat{p}_{Y,i}, and compare the three. What does the comparison say about context as the resolver of ambiguity, and where does Exercise 4’s independence model misdescribe what you observed? Record the model identifier and the date beside your results.