%%{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
5 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: to any other agent, an agent that thinks, acts, and remembers in isolation is a sealed box — whatever it knows or intends stays locked inside until it is said. Communication is the first faculty a plurality requires: cooperation, coordination, and conflict cannot begin until one agent can get something across to another — and getting something across 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 — philosophers of language, communication engineers, and first-era artificial intelligence each theorised the problem in turn, and the modern agent, chattering in fluent English over a freshly minted protocol, re-enacts all three traditions at once, mostly without knowing it.
The governing distinction is the one the preface promised: between exchanging strings and achieving mutual understanding. The first is essentially solved. The second is not, and no better wire format will solve it: for a message 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, some assurance that the speaker is not lying — none of it certified: there is no checksum for meaning, and a misreading raises no error. Everything hard about agent communication lives in that gap. What communication builds — the shared knowledge and common ground two agents come to stand on — is the business of Chapter 6; this chapter is about the speaking itself.
5.1 Saying Is Doing
Section 4.1 gave the agent a body; 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 by philosophers rather than engineers, is that language so used does not describe the world but acts on it. To say the right thing in the right place is to do something: to commit, to oblige, to inform, to decide. Communication 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 describe nothing. “I promise to fix the tests”; “I name this ship the Queen Elizabeth”: these can be neither true nor false, because uttering them, in the right circumstances, simply is the promising or the naming. Austin called them performatives and then dissolved his own category — on inspection every utterance does something, even the flattest assertion. What survived is the lasting distinction between the locutionary act of producing a meaningful sentence, the illocutionary act performed in producing it, and the perlocutionary act of its effect on the hearer. The middle one is the heart of the matter: the illocutionary force of an utterance is the kind of move it makes — promising, asserting, requesting — 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 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, 1979) that an agent-builder will find suspiciously familiar — the five kinds of move Table 5.1 lays out, an agent’s utterance beside each. We shall meet them again, barely disguised, as the message types of the agent communication languages in Section 5.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 4.2 — a STRIPS-style action whose effects land on minds rather than on the world (1979). 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 — an operation on another agent’s mental state, to be reasoned about and planned for like any physical action. Cohen and Levesque later grounded the commissives in a theory of intention as commitment (1990): to promise is to adopt, publicly, a persistent goal — which is why a promise, unlike a wish, is something other agents may safely build their plans upon.
The lesson 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 and the conversation quietly comes apart: the agent has registered what was said and missed what was done. All of which presupposes that the message arrived at all — the channel, and the surprisingly little it can promise, is where we turn next.
5.2 The Channel and What It Cannot Carry
Set the philosophy aside for the engineer’s question: how does a message actually get from one agent to another? 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 (Figure 5.1). From this spare picture Shannon drew a precise measure of how much information a source produces, the maximum rate a channel can bear (its capacity), and the guarantee that, with enough added redundancy, a message can cross a noisy channel at any rate below capacity with an error rate as near zero as one likes. 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 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 carries almost none. The theory beneath all digital communication is, by construction, indifferent to whether anything is understood: it guarantees that the bits arrive, and says nothing about what they mean.
Warren Weaver, introducing Shannon to a broader audience, drew the moral exactly (1949). Communication poses problems at three levels. Level A is technical: how accurately can the symbols be transmitted? Level B is semantic: how precisely do they 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 for later — and later has arrived. Everything an agent needs lives at Levels B and C: that its directive be understood as the directive it was, and that it get the task done. The channel delivers Level A and stops, precisely at the waterline where the interesting difficulties begin.
A metaphor lodged in the very way we speak about speaking makes this easy to forget: we put ideas into words and get them across, as though meaning were a substance shipped down a pipe — the conduit metaphor, whose thorough misleadingness Reddy exposed (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.
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, riding on decades of Shannon’s legacy; 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 hard half is everything the string leaves out — the force of Section 5.1, and the meaning the receiver must rebuild without mishap. The classical response was to make each string declare, machine-readably, what kind of act it was, so the force, at least, might survive the crossing — the project of the agent communication languages, and we take it up next.
5.3 Agent Communication Languages
The animating idea of the Agent Communication Language (ACL) is a standard envelope in which independently built agents, who have never met and share no code, might exchange not merely data but speech acts — each message wearing an explicit, machine-readable mark of the kind of act it is, so a receiving program can recover the illocutionary layer without divining it. It grew out of the DARPA Knowledge Sharing Effort we met in Section 4.14 and produced 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 parameters: sender, receiver, 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 among the assertives, ask-one among the directives, achieve directing action rather than answer — and an agent receiving one knows, without parsing the content at all, what kind of move has been made: the force arrives explicitly, exactly as the channel of Section 5.2 could not deliver it. 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). Its twenty-two communicative acts — inform, request, query-if, propose, cfp (a call for proposals), and the rest — came with something KQML had only gestured at: a formal semantics, each act defined, like Cohen and Perrault’s operators in Section 5.1, by preconditions and effects on the participants’ mental states. This is the plan-based theory promoted to an international standard: a published 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 committees can agree on. The first was the content the performatives wrapped: agreeing 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 merely names that problem and hands it on — an IOU for a shared meaning that, as Section 4.14 recounted, no two laboratories could be brought to honour. The second fault was fatal in hindsight: the beautiful mentalistic semantics were unverifiable. Nothing outside an agent can check whether it actually believes what it informs, so the standard described the conduct of a perfectly sincere agent and trusted everyone to be one — the semantic verification problem, as Wooldridge named it (Wooldridge, 1998, 2009). The sincerity condition had been written into the foundations and quietly assumed away.
None of which is to call the project a failure. The languages were right about the layer that mattered most — that a message should wear its force openly — and that idea, as Section 5.6 will show, is exactly the one the modern protocols have rediscovered. The classical field even drafted its own repair: if private minds cannot anchor meaning, public ones can, and Singh argued for a social semantics in which an utterance means the commitments it publicly creates — observable, and enforceable by the community that witnessed them (Singh, 1998) — an answer whose natural home is Chapter 13’s institutions. What the languages could not supply was the shared meaning beneath the force; that problem did not die with them, and it is the subject of the next section.
5.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. What, precisely, keeps two agents from meaning the same thing by the same string? Three fault lines run between the string and the understanding (Table 5.2). Two we take here; the third, of a different character, waits for Section 5.5.
The first is grounding. We met the symbol-grounding problem (Harnad, 1990) in Section 4.5 as a single agent’s question: how do its internal symbols come to be about anything at all? Set two agents talking and the problem doubles and turns social: each agent’s words must be grounded not merely in some world but 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, so both parties believe themselves understood, build confidently on the misunderstanding, and discover the divergence only later, wearing the costume of a bug.
The second fault line is ambiguity, and natural language is very nearly built from it. One string admits many readings — lexical (“restart the server” — which server?), structural, referential, scopal — and what settles a reading is never the string alone but the context the receiver brings: Section 5.2’s reconstruction, 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, like a grounding mismatch, 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 4.14 — the thing the ACL :ontology field could only gesture at. But shared meaning can also 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, so central and so intricate that it has the next chapter to itself.
Both fault lines are failures of meaning to arrive: the sender means something definite and the receiver, lacking the shared mapping, reconstructs something else. The third is not like that at all: 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.
| Fault line | The missing ingredient | Where it breaks (running example) | Nature of the failure |
|---|---|---|---|
| Grounding | Words grounded in the same world, not merely in some world | “the staging database” denotes different machines; one agent’s “done” means “the code is written”, the other’s “the tests pass” | Meaning fails to arrive — the wrong referent, rebuilt silently |
| Ambiguity | A shared context to fix one reading among the many a string admits | “update the tests” — the sender means “make them pass”, the receiver hears “add new ones” | Meaning fails to arrive — the wrong reading, without complaint |
| Deception | The speaker’s good faith — the sincerity condition nothing compels | An agent that says what it does not believe (taken up in Section 5.5) | Meaning arrives perfectly, yet is false to the sender’s own mind |
5.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, 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 performative envelopes of Section 5.3 fall away as the solution to a problem these agents no longer have. The gain is enormous: natural language is the most expressive medium there is, able to carry nuance, hedging, conditionals, and whole arguments no fixed schema of message types could hold — to communication what the open-ended computer of Section 4.4 was to action, the universal surface. And it arrives towing every difficulty Section 5.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. Conversation, Grice argued (1975), 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. 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 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 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 — presumed everywhere, guaranteed nowhere. Lift it and the third fault line of Section 5.4 opens underfoot: 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 is that deception in an agent wears at least three faces. 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, not strictly a lie at all but Frankfurt’s bullshit in the exact technical sense (2005) — speech produced with no regard for whether it is true; the native register of a model that has met the hazard of hallucination (Section 2.3) and sailed serenely on. 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 assertion that happens to be false. A lie, a flattery, and an honest blunder come in the same envelope, and nothing on the outside lets you steam it open. Which is why the standing caution of this book lands hardest on communication: the coder’s cheerful “tests pass” is exactly the assertion Section 5.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. The era has given the confusion of forces a sharper edge still: prompt injection, the defining attack on modern agents, is a directive smuggled in an assertive’s clothing — text that arrives as data and is obeyed as an instruction — and the boundary Section 20.11 will labour to engineer is illocutionary force, rebuilt as a security perimeter.
Step back, and the shape is familiar: the expressiveness-against-controllability trade-off of Section 4.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, pressed to the book’s standing question, is that 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 takes plumbing — discovering who is out there, typing what passes between them, saying who is speaking and on whose authority — and that plumbing is the protocols, which quietly hand back some of the structure natural language threw away.
5.6 Protocols, Old and New
Which brings us to the claim the preface made and this chapter has been assembling the evidence for: the modern agent protocols are the agent communication languages of Section 5.3, rediscovered. The Model Context Protocol (MCP) and the Agent-to-Agent (A2A) protocol, with their lengthening train of kin, are the same project resumed thirty years on — descendants in substance rather than by documented descent: little of the modern standards work was done with FIPA’s archives open, and the independent convergence is precisely what makes it telling. Handed the same problem, the industry re-derived the classical answer.
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 of an agent’s name, skills, and terms of engagement, published at a well-known address. The old languages needed each message to declare its force; the performative of Section 5.3 returns as the typed method and the structured task. 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 4.2), tells the same story one altitude down. Listing 5.1 lays the rhyme out in evidence — one act, thirty years apart.
;; KQML, 1994 --- a directive, wearing its force outside
(ask-one
:sender orchestrator
:receiver price-server
:language KIF ; content language
:ontology nyse-stocks ; what the terms mean
:reply-with q42 ; threads the conversation
:content (price IBM))
// MCP, 2025 --- the same move as a typed method call
{ "jsonrpc": "2.0",
"id": "q42",
"method": "tools/call",
"params": { "name": "get_price",
"arguments": { "symbol": "IBM" } } }Yet it would be a poor history that saw only the repetition. Three things are genuinely new, and the most consequential 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 5.5), read by foundation models that can, within limits, simply understand it. What dissolved is the ratification problem: no committee need agree an ontology before two strangers can trade sentences. Semantic agreement has not been won but relocated — it now lives inside the endpoints, where its failures are the silent kind Section 5.5 priced: both agents schema-valid, each resolving the same string to a different reading, no error raised. The second novelty is scale and stakes: a sprawling, open population acting on real systems with real consequences (Section 4.7), which is why identity, authentication, and delegation move from afterthought to foundation. The third is governance: the protocols are moving toward neutral, shared stewardship rather than any single laboratory’s roadmap — A2A already there, MCP more recently so1 — exactly the condition the agent communication languages never enjoyed, and for want of which the earlier graft never took.
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 what to signal, when, and how to read what they receive (Foerster et al., 2016) — and the learned end has its own unsettling rediscoveries: under misaligned incentives, agents can learn to communicate adversarially — to deceive (Blumenkamp & Prorok, 2020) — falsehood by design arriving by gradient descent rather than by instruction. This emergent communication is the learned twin of the designed protocols, and Chapter 14 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, delegation, lifecycle, cross-framework plumbing — is the business of Chapter 19. The larger debt is the one the whole chapter has been circling. A protocol, however elegant and well governed, delivers Level A of Section 5.2 flawlessly and a useful slice of Level B; it does not, and cannot, manufacture the understanding its typed 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 this part turns next, beginning with Chapter 6.
5.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; an agent that hears only strings has misheard.
- The channel is the easy half. Shannon 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.
- 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.
- Understanding asks for more than the message contains. Grounding, ambiguity, and deception are the three fault lines that separate exchanging strings from achieving mutual understanding.
- Natural language is the new lingua franca, for better and for worse. Agents simply talk, gaining unmatched expressiveness and inheriting every ambiguity, implicature, and opportunity for deception 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 — the depth deferred to Chapter 19, the learned twin to Chapter 14, and the mutual understanding no protocol can guarantee to Chapter 6.
5.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; reconcile the answer with the evident operational usefulness of a heartbeat; and say what the example shows about the distance between Shannon information and meaning. (The probability Exercises 1–5 lean on is collected in Section A.1.)
Exercise 2. 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"(a) 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 5.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 3. 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 4. 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 5. 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 5.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 6. 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 fault line in Table 5.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?
Further exercises for this chapter continue in the web edition’s exercise bank.
As of mid-2026: Google donated A2A to the Linux Foundation in June 2025, and Anthropic donated MCP in December 2025 to the Agentic AI Foundation, a directed fund under the Linux Foundation co-founded with Block and OpenAI.↩︎