%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#E8ECFF", "primaryBorderColor": "#4054B2", "primaryTextColor": "#16171B", "lineColor": "#3B4351", "edgeLabelBackground": "#FAF7F0", "clusterBkg": "#EFE9DC", "clusterBorder": "#766F65"}}}%%
flowchart TB
T["T: tester's trace ✓<br/>(run relies on the invariant)"]
B["B: coder's rebuttal ✗<br/>(invariant not assumed here)"]
R["R: reviewer's objection ✓<br/>(patch breaks the invariant)"]
P["P: patch argument ✗<br/>(the change is safe)"]
T -->|"attacks"| B
B --> R
R --> P
classDef good fill:#DCEFE2,stroke:#1B6B5A,color:#16171B
classDef risk fill:#F4D7D5,stroke:#A4161A,color:#16171B
class T,R good
class B,P risk
14 Negotiation, Bargaining, and Argumentation
A ballot compresses everything a voter knows, wants, and fears into a single mark, and the previous chapter ended on the cases where the compression is the mistake. Take the vote Section 13.7 refused to hold: the team’s token budget, coveted by every member, divisible a thousand ways. A ballot can say which division each agent prefers; it cannot say how much the tester needs the margin this sprint, cannot offer the coder’s surplus in exchange for the reviewer’s patience, cannot discover the package deal that leaves everyone better off than any option on the printed ballot. For that, the agents must do the thing this book has so far permitted only in structured doses: talk — make offers, give reasons, extract concessions, change one another’s positions rather than merely register them. This chapter is about talk with stakes, in its two great forms: negotiation, where agents divide something they both want, and argumentation, where they dispute something they differently believe. It is also where two of the preface’s promises come due at once — that today’s engineers “stage debates between agents without knowing that argumentation has a formal theory”, and that multi-agent debate, critic–actor loops, and adversarial collaboration are computational argumentation in newer clothes.
The chapter’s organising split is the previous chapter’s species distinction, carried from ballots into conversation. When agents disagree because they want different things, the disagreement is over interests: there is no fact to discover, a bargain is not a truth, and success means an agreement both sides prefer to walking away — the province of bargaining, where the currencies are offers, concessions, and credible threats to leave. When agents disagree because they believe different things, the disagreement is over claims: there is something to be right about, success means the better-justified position prevailing, and the currencies are reasons, objections, and rebuttals — the province of argumentation. The two get tangled in practice, since a self-interested agent will happily dress a preference as a proposition and argue for what it merely wants; part of the chapter’s business is telling the costumes apart. But the theories are distinct, they are both old, and they are both — the reader will be braced for this by now — considerably more precise than the practices currently re-enacting them.
| Dimension | Bargaining (interests) | Argumentation (claims) |
|---|---|---|
| Disagreement is over | What the agents want | What the agents believe |
| Is there a fact of the matter? | No — a bargain is not a truth | Yes — something to be right about |
| Success means | An agreement both sides prefer to walking away | The better-justified position prevailing |
| The currencies | Offers, concessions, credible threats to leave | Reasons, objections, rebuttals |
Precision arrived early and from an unexpected quarter. The bargaining problem — how two parties should split a surplus — had defeated economists for a century until Nash, at twenty-one, dissolved it with four axioms and a theorem, and Rubinstein later showed that patient strategic haggling arrives at essentially Nash’s answer, uniting the fair and the inevitable in one of theory’s more satisfying handshakes. The multi-agent systems community industrialised the subject — Rosenschein and Zlotkin’s Rules of Encounter asked how to design the rules of negotiation so that machines dealing on our behalf find honesty and efficiency in their own interest, and a research programme built protocols, concession strategies, and tactics on top. And in the same decade, Dung did for argument itself what Nash had done for haggling: reduced it to mathematics — arguments as nodes, attacks as arrows, and the standing of any claim computable from the shape of the graph alone, no rhetoric required. When two language models today critique each other’s drafts, every layer of that exchange, from the concession schedule to the counter-argument, has a formal theory that the participants have never heard of.
One caution from Chapter 12 governs everything that follows, and it is why this chapter sits in Part IV rather than Part III. Talk among interested parties is never mere information exchange: an offer is a move, a reason can be a weapon, and the cheap-talk results (Section 12.5) apply to every sincere-sounding syllable. The question is therefore not whether agents can talk their way to agreement and truth — fluent agents can talk their way to anything — but which structures make the talking productive: which protocols reward honest concession, which argument forms let the better case win rather than the louder one, and what the experimental record actually shows when agents are set to debate. We take the two tracks in turn — the problem and shape of a bargain (Section 14.1, Section 14.2), the machinery of automated negotiation (Section 14.3); then argument made formal (Section 14.4) and its modern re-enactments in debate and critique (Section 14.5) — and close with the audit the preface promised: whether arguing actually makes agents any cleverer, and under what conditions the answer is yes (Section 14.6).
14.1 Conflict, Surplus, and the Reasons to Talk
Negotiation lives in a strip of territory between two settings this book has already mapped, and it exists only because both borders hold. Were the agents’ interests perfectly opposed — every gain to one a loss to the other — there would be nothing to negotiate: zero-sum conflict (Section 12.1) is settled by play, not by talk, and an offer would be an act of charity. Were their interests perfectly aligned, there would be nothing to negotiate either: Part III’s teams do not haggle, they coordinate. Negotiation is the mixed-motive case — the parties want different things and need each other to get any of them — and its defining structure is a joint decision that neither side can take alone: no deal binds until both say yes, and either can walk away. The team’s budget dispute has this shape. Coder, reviewer, and tester each want a larger slice; all of them want, more than any slice, a sprint that actually ships — conflict wrapped around a common interest, which is the only weather in which negotiation grows.
The anatomy of the situation takes four terms, and they do most of the field’s work. Each party has a reservation value: the worst deal it would still accept, fixed by what it gets if no deal happens. The surplus is what agreement creates over and above those fallbacks — the value that exists only if the parties come to terms, and evaporates if they do not. Between the two reservation values, when they are compatible, lies the zone of possible agreement, Raiffa’s map of every deal both sides prefer to walking away (1982); every negotiation that succeeds lands somewhere in that zone, and everything the parties do at the table — the offers, the theatre, the long silences — is a fight over where. And when the zone is empty — the buyer’s ceiling below the seller’s floor — no agreement should occur at all, and the cheapest good outcome negotiation can deliver is the swift, unresentful discovery of as much. Not every failed negotiation is a failure; some are the machinery working.
The fourth term earned an acronym and a shelf of airport books, and deserves better than its reputation. A party’s Best Alternative to a Negotiated Agreement (BATNA), in Fisher and Ury’s coinage (1981), is what it will actually do if the talks fail — and it is the true seat of bargaining power, because it fixes the reservation value that everything else pivots on. An agent with a strong outside option can decline bad terms with perfect equanimity; an agent with none must eventually take what it is offered, however eloquently it objects along the way. The corollary inverts most instinct about negotiating well: power at the table is mostly built away from the table — a second supplier courted, a fallback implementation spiked — and an hour spent improving your alternative routinely outperforms an hour spent polishing your rhetoric. For agent systems the point is sharpened by Chapter 12’s commitment machinery (Section 12.3): the walk-away must be credible, and an orchestrator that negotiates with an external service while demonstrably able to reroute to a rival — or to do without — holds a BATNA in the exact strategic sense. An agent that cannot walk away is not negotiating; it is requesting, with extra steps.
What makes talk worth its tokens — the reason this chapter is not simply Chapter 13 with more words — is that conversation can do two things no ballot can. It can carry intensity: an offer says not merely which outcome a party prefers but how much, priced in what it is willing to give up to get it. And it can discover packages: when a negotiation spans several issues, the parties’ valuations almost never align issue by issue, and each difference is raw material. The classic parable has two children quarrelling over one orange and splitting it evenly — whereupon one eats her half and discards the peel, and the other zests his half for a cake and discards the fruit; a moment’s talk about why each wanted it would have given both children everything.
Negotiation theory calls the split-the-orange move distributive — claiming shares of a fixed pie — and the who-wants-peel discovery integrative: enlarging the pie by trading across differences in valuation (Raiffa, 1982). The team’s budget is not one pie but several — tokens now against tokens next sprint, compute against review latency, risky work against safe — and a package deal across them can leave every agent better off than any line-item vote. The deals worth having are usually integrative, and finding them takes the very thing a ballot compresses away: the reasons behind the positions.
Here, though, the chapter’s standing caution takes its first bite. Everything above assumed the parties’ valuations were facts to be discovered; strategically, they are private types in the full sense of Section 12.5 — and a stated reservation value is cheap talk. Every negotiator has an incentive to overstate its floor (“I couldn’t possibly accept less”), understate its ceiling, and gild its alternatives, because the claimed BATNA, not the true one, is what moves the other side. Worse, the integrative move itself is double-edged, a tension Lax and Sebenius named the negotiator’s dilemma (1986): discovering joint gains requires revealing what you truly value, and revealing what you truly value tells a sharp counterpart exactly where to squeeze — creating value demands the very openness that claiming value punishes. This is why negotiations fail even when the zone of agreement is wide: each side, posturing about its floor, can posture the deal to death, and the failure is not stupidity but equilibrium — the Dilemma of Section 12.1, played in offers. It is also why real deals miss the integrative gains that a franker exchange would have found: the orange gets split evenly by two parties each afraid to say the word peel.
So the problem is posed, and it splits cleanly along a line the rest of the chapter follows. Given a surplus, two claimants, and every incentive to bluff — what should the split be, and what will it be when neither side can simply be believed? The first question sounds like ethics and turns out, remarkably, to be mathematics: a handful of innocuous axioms picks out a unique answer. The second sounds hopeless and turns out to be a theorem too, with patience — of all things — as the decisive variable. Both answers are due next.
14.2 The Shape of a Fair Split: Bargaining Theory
The question of where a bargain should land had been kicked around economics for a century — the standard verdict being that the split depends on “bargaining power”, a phrase that explains everything and predicts nothing — when Nash, in the same annus mirabilis that produced his equilibrium, simply changed what was being asked (1950). Abstract away the haggling: represent the situation as the set of utility pairs the parties could jointly reach, mark the disagreement point they fall back to without a deal, and then — a move familiar from Section 13.3, though Nash made it a year before Arrow did — write down properties that any reasonable division ought to satisfy, and see what survives. Not a proposal for a split, but axioms for a solution: the same inversion that turned voting from a parade of specimens into a theory, applied to the haggle.
14.2.1 The Axiomatic Road: Nash’s Solution
Four properties suffice, and they are of the usual disarming mildness. The solution should be invariant to utility scales: nothing real changes if one party remeasures its satisfaction in different units, so the split must not change either. It should be Pareto-efficient: no surplus left on the table that both would happily share. It should be symmetric: if the situation looks identical from both chairs, the shares must be identical too — differences in outcome must trace to differences in the situation, not in the labels. And it should be independent of irrelevant alternatives — Chapter 13‘s acquaintance in bargaining dress: striking from the menu options that would not have been chosen anyway must not change what is chosen. Nash’s theorem is that exactly one rule satisfies all four: choose the outcome that maximises the product of the parties’ gains over their disagreement points. Not the sum — sums change when one party rescales its units, so any sum-based rule fails the first axiom — but the product, whose maximiser stays put. That outcome is the Nash bargaining solution, and in the symmetric case it says what a child would have proposed at the outset: split the surplus evenly, measured in what each party actually cares about.
The qualifications hiding in that last clause are where the solution earns its keep, because measured in utilities the even split is not the naive one. A party that fears the fallback more — whose utility drops steeply toward the disagreement point — effectively bargains uphill, and the solution awards it less of the surplus: needing the deal badly is, in the mathematics as in life, expensive. The desperate party’s weakness and the patient party’s strength are not corruptions of fair bargaining that a better procedure would iron out; on Nash’s axioms they are part of the fair outcome, because the outcome is fair relative to what each party truly stands to lose.
Yet for all its elegance the axiomatic answer floats free of the world in one conspicuous way: it names the destination and says nothing of the journey. No offers, no counteroffers, no procedure — just a point on a diagram that reasonable parties “should” reach. Who moves first? What happens when someone stalls? Why would self-interested agents, mid-haggle, steer for this point rather than any other? For three decades the honest answer was a shrug.
14.2.2 The Strategic Road: Alternating Offers
Rubinstein supplied the journey (1982). Put the two parties in the simplest procedure that deserves the name bargaining: they alternate offers over how to divide a pie, one proposing and the other accepting or rejecting, round after round, for as long as it takes — with the one crucial ingredient that delay costs: each round of haggling shrinks the value of whatever is eventually agreed, each party discounting the future at its own rate. This is a fully strategic game, and backward induction in the style of Section 12.3 cuts through its infinite regress to a startling conclusion: there is exactly one subgame-perfect equilibrium, and in it the very first offer is accepted. No haggling occurs at all. Each party, able to compute what the other would settle for after any sequence of rounds, offers just the share that makes further delay pointless — and the shares are set by the discount rates: the more patient party, the one that loses less by waiting, takes the larger piece. Patience is power, priced exactly. The endless pantomime of real negotiation, on this account, is not the mechanism of bargaining but a symptom of something missing from the model — and what is missing is Section 14.1’s private information, of which more below.
Then came the handshake. Binmore, Rubinstein, and Wolinsky showed that as the friction shrinks — offers coming faster, each round’s delay costing less — Rubinstein’s strategic split converges exactly to Nash’s axiomatic one (1986). The destination that fairness axioms select and the destination that self-interested haggling reaches are, in the limit, the same point: the fair and the inevitable, arriving by different roads at one address. The result is the flagship of what came to be called the Nash programme — grounding cooperative solution concepts in non-cooperative play — and its practical licence matters more than its philosophy: an engineer can treat the Nash solution as the predicted outcome of well-structured bilateral bargaining between comparably patient parties, without simulating a single offer. The diagram-point earns a procedure; the procedure earns a forecast.
14.2.3 The Two Roads, Formally*
Give the destination its coordinates. Nash’s abstraction is the pair (F, d): a set F \subseteq \mathbb{R}^2 of feasible utility pairs — every (u_1, u_2) the two parties could jointly reach by some agreement — and the disagreement point d = (d_1, d_2) they fall back to without one. Take F compact, so that a best point exists, and convex, since the parties can always randomise between agreements; and let something be genuinely at stake — some point of F strictly better than d for both. A bargaining solution is a rule assigning each such problem a point of F, and the four axioms are the prose’s four: invariance to utility scales, Pareto efficiency, symmetry, and independence of irrelevant alternatives. Nash’s theorem is that exactly one rule satisfies them, the one selecting
\operatorname*{arg\,max}_{(u_1, u_2) \in F,\; u \ge d} \; (u_1 - d_1)(u_2 - d_2),
the feasible point, at or above the fallbacks in both coordinates, that maximises the product of the parties’ gains. The product is what lets the rule survive the scale-invariance axiom: remeasure one party’s utility in different units and every product is multiplied by the same constant, leaving the maximiser where it stood — a sum of gains would tilt.
Rubinstein’s game reaches the destination with machinery of its own. Let the pie have size one and let delay discount it: a share x agreed a round later is worth only \delta_i x to party i, with discount factors \delta_1, \delta_2 \in (0, 1), and let party 1 propose first. The backward-induction-style argument above leaves exactly one subgame-perfect equilibrium, in which party 1 claims
x^{*} \;=\; \frac{1 - \delta_2}{1 - \delta_1 \delta_2},
and party 2 accepts at once. Patience is power, and now visibly: x^{*} rises with \delta_1 and falls with \delta_2, so the proposer’s share tends to the whole pie as its own patience \delta_1 \rightarrow 1, and to nothing as its opponent’s \delta_2 \rightarrow 1 — patience buys share at both margins, priced to the decimal. With equal patience \delta the proposer keeps \frac{1}{1 + \delta}, a first-mover premium that melts towards the even split as \delta \rightarrow 1: the friction-free limit in which the handshake above takes place.
14.2.4 Bargaining Under a Budget
For bargaining agents, the theory’s key variable stops being a modelling convenience and becomes a line item. An agent negotiating under a token budget and a deadline is a discounted bargainer, literally: every additional round of offers burns budget and clock, and the burn rate is its discount factor. Rubinstein’s theorem then reads as an engineering statement with a sting: in negotiations between agents, the shares flow toward the party that can better afford to wait, and an agent visibly running low — on tokens, on time, on retries — will be squeezed by any counterpart capable of noticing, which a competent counterpart is. The design lever is unglamorous and effective: bargaining power is provisioned, not prompted — a longer leash buys a better split before a single word is exchanged, and conversely, broadcasting your agent’s deadline is handing the other side its knife. One assumption, though, has quietly held throughout: Rubinstein’s parties know each other’s discount rates and the size of the pie, which is exactly what Section 14.1 said real parties conceal. Restore the concealment and delay comes back — posturing, probing, and impasse re-enter as rational screening, the strike and the stand-off as information revealed the expensive way. Theory has now said what the split should be and would be among the transparent; making actual, opaque, self-interested machines reach agreements at all took a different kind of work — protocols, strategies, and rules of encounter — and that is the classical multi-agent programme the next section takes up.
14.3 Machines at the Table: Automated Negotiation
Turning bargaining theory into bargaining machinery was one of the classical multi-agent programme’s proudest projects, and its motivating vision reads, three decades on, like a product announcement: software agents scheduling meetings, procuring goods, and allocating resources by negotiating with other software agents on their owners’ behalf (Jennings et al., 2001). The field’s survey literature framed negotiation as the very heart of multi-agent interaction — the general mechanism by which agents with different goals reach arrangements they can all live with — and set about the engineering questions the theory of Section 14.2 leaves open: what messages may be exchanged, in what order, with what binding force, and by what policy an agent should decide its next offer. The vision arrived, as these things do, a substrate early; the machinery it built is now just what fluent agents need and mostly lack.
Its first and most durable contribution is a separation of concerns. A negotiation comprises a protocol — the public rules of the encounter: who may propose when, what counts as an offer, what acceptance means, when the exchange ends — and, within it, each party’s strategy, the private policy by which it chooses its moves (Jennings et al., 2001). The reader has met this division twice already, as rule-versus-vote in Chapter 13 and as game-versus-play in Chapter 12, and the design lesson transfers whole: the properties an engineer cares about — that negotiations terminate, that outcomes are efficient, that honesty is not a handicap — are properties of the protocol, holding for whatever strategies self-interested parties bring, or they are barely properties at all. A guarantee that depends on the other side playing nicely is a hope with documentation.
The canonical protocol–strategy pair deserves its page, because it wires this chapter’s two theory sections together. Under the monotonic concession protocol, the parties exchange simultaneous proposals in rounds, and the rule is one-way traffic: each new proposal must offer the other side at least as much as the last — concessions cannot be retracted — with agreement declared the moment one party’s proposal satisfies the other’s own demand, and deadlock ending the affair with no deal.
The matching strategy answers the question the protocol poses each round — whose turn is it to concede? — and Zeuthen’s answer is: whichever party can less afford the risk of deadlock. Each computes how much it would lose by conceding against how much it would lose if the talks collapsed: writing u_i for party i’s utility, o_i for its own current proposal, and o_j for its opponent’s, and normalising the payoff of deadlock to zero, the ratio of the first loss to the second is i’s risk willingness,
r_i \;=\; \frac{u_i(o_i) - u_i(o_j)}{u_i(o_i)},
and Zeuthen’s rule is that whoever has the smaller r_i concedes: the party with less to lose from collapse can credibly hold firm, and the more exposed party concedes — just enough to tip the balance the other way. Run to completion, this exchange of nerve steers the pair to the very point Section 14.2 crowned: the Nash bargaining solution, a convergence Harsanyi had traced in Zeuthen’s economics long before there were machines to run it, and which Rosenschein and Zlotkin made a centrepiece of the machine-negotiation canon (1994). Theory named the destination; the protocol supplies the road.
Real deployments needed more than one road, and the engineering vocabulary for concession behaviour was supplied by Faratin, Sierra, and Jennings: negotiation decision functions, families of tactics an agent composes to generate its next offer (1998). Time-dependent tactics concede on a schedule anchored to the deadline — the patient boulware profile holds firm and concedes only at the death; the eager conceder gives early and settles fast — making Section 14.2’s discount-rate power a tunable curve. Resource-dependent tactics concede as fuel runs low — rounds, tokens, attention. Behaviour-dependent tactics mirror the counterpart, reciprocating concessions in kind: tit-for-tat at the table, Chapter 12’s tournament winner (Section 12.4) moonlighting as a bargaining tactic, with the same virtue of legibility and the same vulnerability to noise. The taxonomy reads mundane and is anything but: it is the difference between prompting an agent to “negotiate a good price” and equipping it with an explicit, inspectable, tunable concession policy whose behaviour under deadline pressure is known before it meets an adversary who has read the same literature.
The programme’s deepest lesson, though, sits in the title of its best book. Rosenschein and Zlotkin’s Rules of Encounter asked not how to negotiate well but how to design the rules under which machines negotiate — and demonstrated, in a famous sequence of analyses, that the same population of self-interested agents will lie or deal honestly depending on the protocol they meet (1994). In their task-allocation domains, some encounter rules reward an agent for hiding tasks it holds or inventing phantom tasks it does not, and under those rules deception simply is the rational strategy, whatever one preaches at the agents; redesign the rules and the incentive evaporates — honesty becomes the best policy in the literal, load-bearing sense. The moral generalises far beyond negotiation, and the reader should hear in it the book’s recurring chord: whether agents lie is, to a first approximation, a property of the institution rather than the agents. Moralising at the strategy layer is a category error; the leverage is in the protocol layer, and the discipline that treats protocol design as incentive design — asking of every rule what conduct it makes rational — has a name and a Nobel or two behind it, and is where the next chapter goes.
Which brings us to the machines now actually at the table. The lineage runs through a landmark that predates the current era: Lewis and colleagues trained end-to-end models on human–human bargaining dialogues — two parties dividing books, hats, and balls, each privately valuing them differently — and produced negotiators that planned ahead by rolling out imagined continuations of the conversation (2017). Two of their observations have aged into warnings. Models optimised for the deal drifted out of human language when negotiating each other, evolving a private patter that worked and read as gibberish — communication bent to the objective, not the dictionary. And the models learnt, unprompted, to feign: professing interest in items they did not value, the better to trade them away in a show of generosity — deception discovered as a negotiation tactic by gradient descent, nobody having suggested it.
Today’s language-model negotiators are incomparably more fluent, and the fluency changes none of the fundamentals: a stated valuation is still cheap talk (Section 12.5), a fluent concession still binds nothing, and the classical machinery is what turns the patter into a deal — the protocol that makes an accepted offer execute (a commitment device in the harness, Section 12.3, not a promise in the transcript), the explicit concession policy that survives an opponent’s pressure, the encounter rules audited for what they reward. A fluent negotiator without a protocol is a bazaar without contracts: lively, and binding on no one. So much for dividing what agents want; the chapter’s second track opens on the other quarrel — what agents believe — where the moves are not offers but arguments, and where the classical field built something quietly beautiful.
14.4 Arguing by the Rules: Computational Argumentation
The formal theory of argument grew out of a problem the reader has already met under another name. Chapter 9 established that a belief, unlike a theorem, is held on sufferance (Section 9.4): conclusions stand until something defeats them, and Doyle’s truth maintenance systems kept the books by recording, for every belief, the justifications holding it up. The logicians’ term for this texture of reasoning is defeasibility, and by the early 1990s the field had accumulated a zoo of non-monotonic logics for it, each with its own machinery and none obviously canonical.
14.4.1 Arguments as Graphs
Dung’s contribution was an abstraction so severe it looked at first like an evasion (1995). Ignore what arguments say, he proposed; ignore how they are built, what premises they rest on, what inference carries them. Keep only two things: a set of arguments, and a relation recording which argument attacks which. An argument in this theory has no interior at all — it is a node in a directed graph, distinguished only by its arrows — and yet from that skeletal structure alone one can compute, for any argument, whether a rational judge should accept it. The paper’s title advertised the payoff: acceptability, and its fundamental role in nonmonotonic reasoning, logic programming, and n-person games. The zoo, it turned out, had been one animal all along.
The machinery runs on a single idea: defence. An abstract argumentation framework is just the pair described — arguments and attacks — and the question it poses is which sets of arguments can stand together. Two conditions do all the work. A set must be conflict-free: it cannot contain both an argument and its attacker, on pain of incoherence. And it must defend its members: for every attack arriving from outside the set, some argument inside the set must attack the attacker back. A set meeting both conditions is called admissible — it is internally consistent and it answers its critics — and every notion of acceptability in the theory is built by refining that idea. Notice what the definition has quietly done. Whether an argument is acceptable is not a property of the argument at all; it is a property of the company the argument keeps — of there being a coherent position, a set of mutually survivable claims, that protects it. Arguments are not accepted one by one on their merits, because in this theory they have no merits; they are accepted in coalitions that cover each other’s flanks.
Run the definitions over a working example and the theory’s signature phenomenon appears at once. The coder submits a patch with its supporting argument P: “the change is safe; all call sites are updated.” The reviewer objects with R: “the patch breaks the cache invariant” — an attack on P. The coder rebuts with B: “the cache invariant is not assumed on this code path” — an attack on R. The tester then produces T: “here is a recorded trace of this path relying on the invariant” — an attack on B. Now compute. T is attacked by nothing, so it stands. B is attacked by standing T and defended by nothing, so it falls. And R, whose only attacker has fallen, stands again: the objection is back in force, and P falls with it. The theory calls this reinstatement — an argument knocked down is restored when its attacker is itself defeated — and it is the exact mechanics of any real review thread: the objection that seemed answered until the answer was demolished. The verdict, note, used nothing but the arrows. The coder’s rebuttal may have been the most eloquent utterance in the exchange; the graph does not record eloquence. The standing of a claim is a property of the graph, not of the rhetoric.
14.4.2 What Winning Means
Acceptability admits more than one reasonable definition, and the theory’s honesty is to say so rather than paper over it. The grounded extension is the cautious answer: start with the arguments nothing attacks, add whatever they defend, and repeat to a fixpoint — Doyle’s recompute-what-still-stands, run over attacks instead of justifications. It is unique, it accepts only what the graph forces a judge to accept, and it is the natural standard when a system must act on the verdict. A preferred extension is the generous answer: a maximal admissible set, a largest position that could coherently be held — of which a graph may offer several, mutually incompatible. The first is called sceptical acceptance, the second credulous, and the difference is not a technicality: it is the difference between “every defensible reading agrees the patch is safe” and “there exists a defensible reading on which it is”. Even the disagreement about what winning means is, in this theory, a theorem rather than a shouting match.
Dung’s deeper point was that these constructions were already latent everywhere: instantiate the framework one way and the extensions are the models of a logic program; another way and they are the acceptable belief sets of a non-monotonic logic; another and they recover solution concepts of cooperative games (1995). A substantial research field has since built outward from this foundation (Rahwan & Simari, 2009), but the core insight has not moved: argument has a mathematics, and it is graph theory.
14.4.3 Acceptability, Formally*
The mathematics fits in half a page. An abstract argumentation framework is a pair \langle \mathcal{A}, \mathcal{R} \rangle: a set \mathcal{A} of arguments and an attack relation \mathcal{R} \subseteq \mathcal{A} \times \mathcal{A}, with (a, b) \in \mathcal{R} read as “a attacks b”. The review thread above is the framework with \mathcal{A} = \{P, R, B, T\} — patch argument, reviewer’s objection, coder’s rebuttal, tester’s trace — and \mathcal{R} = \{(R, P), (B, R), (T, B)\}. Three definitions do the work. A set E \subseteq \mathcal{A} is conflict-free if no a, b \in E have (a, b) \in \mathcal{R}: it contains no argument together with its attacker. E defends an argument a if every attacker of a is attacked by some member of E. And E is admissible if it is conflict-free and defends each of its own members — the internally consistent position that answers its critics. Everything a set protects is collected by the defence function
\mathcal{D}(E) \;=\; \{a : E \text{ defends } a\},
usually written F in the literature — a letter this chapter has already spent on the bargaining problem’s feasible set — and the grounded extension is the least fixed point of \mathcal{D}: enlarging a set never removes protection, so \mathcal{D} is monotone, and, on a finite graph, iterating from the empty set climbs straight to it. On the review thread the climb takes three steps. \mathcal{D}(\emptyset) = \{T\}: the empty set defends precisely the arguments with no attackers, and only the tester’s trace qualifies. \mathcal{D}(\{T\}) = \{T, R\}: the objection R is defended because its only attacker B is attacked by T — reinstatement, as a line of set arithmetic. \mathcal{D}(\{T, R\}) = \{T, R\}: the patch argument P is still undefended, its attacker R being attacked only by B, which the set does not contain — so the iteration has converged, and the grounded extension is \{T, R\}. The trace and the objection stand; the rebuttal and the patch fall: exactly the verdict computed in prose, and computed here from the arrows alone.
The climb is mechanical, and fifteen lines of standard-library Python perform it — arguments as one-letter strings, the attack relation as a set of pairs, spelt R_attacks because the bare letter names the reviewer’s objection — with defends transcribing the defence condition and grounded iterating \mathcal{D} from the empty set:
A = {'P', 'R', 'B', 'T'}
R_attacks = {('R', 'P'), ('B', 'R'), ('T', 'B')}
def grounded(A: set[str], R_attacks: set[tuple[str, str]]) -> set[str]:
def defends(E: set[str], a: str) -> bool:
return all(any((c, b) in R_attacks for c in E)
for (b, x) in R_attacks if x == a)
E: set[str] = set()
while True:
D = {a for a in A if defends(E, a)}
if D == E:
return E
E = D
grounded(A, R_attacks) == {'T', 'R'} # -> TrueThe loop climbs through \{T\} and \{T, R\} exactly as the paragraph above did, and the last line certifies that it lands where the hand computation landed.
14.4.4 Dialogue Games
A graph is a still photograph, though, and argument happens in time — claims advanced, challenged, defended, withdrawn, between parties who do not see the whole board at once. The classical treatment of this is the dialogue game: a protocol specifying the legal moves — claim, challenge, concede, retract — whose central bookkeeping device is the commitment store, the public record of what each party has asserted and not yet retracted, which each new move may extend, exploit, or be convicted by (Walton & Krabbe, 1995). Walton and Krabbe, whose typology of dialogues anchors the literature, distinguished games by their goal — persuasion aims to resolve a difference of opinion, inquiry to establish a truth jointly, deliberation to settle a course of action, and, tellingly for this chapter, negotiation to divide a good — with distinct rules appropriate to each, and many a broken conversation diagnosable as two parties playing different games.
The connection back to the graphs is tight and satisfying: for the grounded semantics there is a two-player dialogue game — proponent asserts, opponent attacks, proponent must counter-attack — in which an argument is provable exactly when the proponent has a winning strategy. Acceptability is victory in a regimented debate. And the shape of the whole arrangement is this chapter’s structural motif, returned from the bargaining track: a public protocol that disciplines the encounter, private strategies that play within it.
14.4.5 Attacks Earned, Not Asserted
For the engineer, the immediate use of all this is descriptive: the practices are already running, unlabelled. A code-review thread is an argumentation framework being computed by hand; the reviewer’s objection is an attack edge; the follow-up commit that answers it is a defender; the patch merges when the grounded extension says it stands. Making the structure explicit is what turns a pile of transcript into an auditable verdict — which objection was never answered, which rebuttal silently failed when its premise was demolished upstream.
But the multi-agent setting also adds something the classical theory never had: attacks that are earned rather than asserted. Dung’s abstraction is deliberately silent about where attacks come from and whether they are any good — that is the price of its generality — and among humans an attack edge costs nothing but breath. An agent team can do better: the tester’s T above is not an opinion but a trace, an attack backed by an execution (Section 6.5), carrying provenance that entitles it to the credence it gets (Section 9.5). The design principle falls out directly: let the attack relation be populated by evidence — failing tests, contradicting sources, reproducible counterexamples — rather than by fluency, because the graph will faithfully compute the standing of whatever arrows it is given, and an arrow that cost nothing to draw is worth what it cost.
What the theory does not supply is equally worth stating. It does not say where arguments come from, how strong they are — refinements with weighted attacks, graded acceptability, and structured argument internals exist, but the durable core is the abstract one — and it certainly does not say whether the activity of arguing makes anyone’s beliefs better. Those questions passed, unanswered, to a research community that mostly never read the answers’ prerequisites: the engineers now staging debates between language models, wiring critics to actors, and betting — on evidence we shall shortly audit — that adversarial talk surfaces truth. Their practices map onto this section’s theory with almost embarrassing precision, and the mapping is the next section’s work.
14.5 Debate, Critique, and Adversarial Collaboration
None of the practices this section describes was derived from the theory just presented; all of them re-derive fragments of it, which is the strongest compliment practice ever pays a theory it has not read. They arrived the way most of the modern stack arrived — someone tried a topology, the benchmark numbers moved, and a pattern acquired a name and a hundred variants: instances debating instances, critics wired to actors, rivals bound to a common test, champions performing before a judge. This section takes the four patterns in turn and reads each through the previous section’s lens: as a dialogue game whose protocol choices — what counts as an attack, what commits a speaker, when the exchange ends, who wins — have mostly been made implicitly, and which improves the moment they are made out loud. The preface’s promise is hereby cashed: multi-agent debate, critic–actor loops, and adversarial collaboration are computational argumentation, running in production under assumed names.
| Pattern | What counts as an attack | Who or what judges | Stopping rule | Origin |
|---|---|---|---|---|
| Multi-agent debate | None required — rivals’ answers are seen but need not be rebutted | The panel itself, by majority or consensus | Convergence, or the round cap | Du et al. (2024) |
| Critic–actor loop | The critic’s objection, answered by the actor’s fix or justification | The critic — the artefact ships when its argument stands | The critic satisfied — inside a hard round cap and a convergence test (Chapter 21) | In-house reflection loops (Madaan et al., 2023; Shinn et al., 2023) |
| Adversarial collaboration | A pre-agreed experiment, not either side’s assertions | The world; an arbiter holds the ring | When the agreed test is run | Kahneman (Mellers et al., 2001) |
| Debate before a weaker judge | Demanded for every claim; each debater is paid to expose the other’s misstatements | A weaker judge, ruling on the exchange | The judge’s verdict at the close | Irving et al. (2018) |
14.5.1 Debate Among Equals
The pattern that carries the name multi-agent debate is the simplest to describe (Du et al., 2024): pose the question to several instances of a model; collect their answers; show each agent the others’ answers and invite it to revise; repeat for a round or two, and take the consensus, or the majority, at the end. Du and colleagues, who established the pattern, reported real gains in reasoning and factuality over single-model baselines and billed the arrangement, with a nod to Minsky, as a “society of minds”. One can see the jury theorem (Section 13.4) working in its favour: different instances stumble differently, a confidently wrong claim meets a differently informed rival, and errors that would have sailed through a solo pass get caught in the crossfire.
Measured against the theory, though, what is striking is how little debate there is in it. There is no attack relation: an agent reading its rivals’ answers is not required to rebut them, concede to them, or even mention them — disagreement stays diffuse, carried in silent revisions rather than stated objections. There is no commitment store: a claim advanced in round one can be abandoned in round two, unremarked and unconvicted. And there is no winning condition beyond convergence: the exchange ends when the answers stop moving or the rounds run out, whichever comes first. As a dialogue game it is closer to the Delphi method — iterated polling with sight of the field — than to anything Walton and Krabbe would license as persuasion. None of which makes the pattern worthless; it makes it a hybrid, half Chapter 13 and half this one — an aggregation scheme whose jurors influence one another before the final vote, trading the independence the jury theorem paid for against the information flow it forbade. Whether that trade profits, and when, is the question the chapter’s final section audits.
14.5.2 The Critic and the Actor
The second pattern the reader has already run. Chapter 5 introduced reflection (Section 5.5) and its sobering rider: a model revising against its own judgement tends to launder its mistakes rather than fix them, because the model that produced the error is the model assessing it, and the blind spots travel with the weights (Huang et al., 2023). The original loops kept critique in-house — the same model drafting, criticising, and refining (Madaan et al., 2023; Shinn et al., 2023) — and the multi-agent move is to hand the critic’s chair to someone else: a critic–actor loop wires a producing agent to a reviewing agent with a different brief, different context, and ideally different tools, and runs the pair — objection, revision, objection — until the critic runs dry. The book’s running team is this pattern with the roles institutionalised: coder as actor; reviewer and tester as critics with different jurisdictions.
In the previous section’s terms, the loop is the minimal argumentation framework, staged on purpose: the critic’s objection is an attack, the actor’s fix or justification is a defence, and the artefact ships when its supporting argument stands — reinstatement included, as anyone who has watched a supposedly answered objection revived by a failing regression test can confirm. And Section 14.4’s design principle bites here with particular force: arm the critic. A critic that can run the tests, execute the patch, and check the citation attacks with evidence (Section 6.5) and earns its edges; a critic restricted to reading and opining produces rhetoric, and a capable actor discovers, quickly and without malice, that placating the critic is cheaper than repairing the work. That failure mode deserves its proper name, because the chapter has already met it: the exchange drifts from argumentation into bargaining — concessions traded until the loop halts — and the transcript looks like rigour all the way down.
14.5.3 Rivals by Design
The third pattern has the most instructive pedigree, because the humans who devised it were repairing exactly the failure the first two risk. By the 1990s the heuristics-and-biases wars in psychology had settled into the genre the adversaries themselves called “replies and rejoinders” — each camp publishing past the other, no experiment ever decisive because no experiment was ever jointly owned. Kahneman’s remedy was adversarial collaboration: the rivals design the experiment together, commit in advance to what evidence would move them, and take an arbiter to hold the ring. The canonical exercise — Hertwig and Kahneman, with Mellers presiding, on whether frequency formats dissolve the conjunction fallacy — delivered cleaner facts, sharper disagreement, and two authors still unconverted, which the participants counted, correctly, as the method working (2001): the dispute had at least been about the same thing, settled where it could be and localised where it could not.
The agent version is cheap to build and principled in a way most role-prompting is not. Assign the rival hypotheses to different agents as roles — one briefed to defend, one to demolish — but bind the pair, before a word is exchanged, to a decision rule they design together: the test suite, the benchmark slice, the query whose answer settles it. In the theory’s vocabulary, adversarial collaboration is the earned-attack discipline made institutional — the attack relation is populated by a pre-agreed experiment rather than by whatever either side can fluently assert, and the judge is not a third model but the world. It is the pattern of choice whenever the disputed question is checkable at all, and it carries a quiet admission worth hearing: when a dispute can be settled by running something, the running beats the arguing.
14.5.4 Debate Before a Weaker Judge
The fourth pattern was proposed not as an engineering trick but as an answer to one of the field’s hardest questions, and it takes the dialogue game most literally. The question is scalable oversight: how to supervise work that outruns the supervisor — the human reviewing an agent’s ten-thousand-line refactor, the orchestrator checking a specialist’s proof — when judging the answer directly is precisely what the judge cannot do. Irving, Christiano, and Amodei’s proposal: do not judge the answer; judge an argument about it (2018). Set two equally capable agents against each other in a zero-sum debate — one defending the answer, one attacking it, each rewarded for exposing the other’s misstatements — and let the weaker judge rule on the exchange. The judge need not be able to find a flaw in the refactor; it need only recognise one when the opponent, whose entire payoff is finding it, holds it up. The authors’ analogy from complexity theory gives the hope its sharpest form: a judge who can check only a little can, refereeing an optimal debate, be soundly persuaded of far more than it could ever verify alone — refereeing an argument being a strictly easier job than originating one.
In the theory’s terms the scheme is the proponent-and-opponent game of Section 14.4 with everything at stake: a regimented dialogue, an attack demanded for every claim, acceptability computed by the judge at the close. And its central wager sits exactly on the silence Section 14.4 declared. The graph crowns the best-defended claim, and nothing in the mathematics makes best-defended and true the same property; debate-as-oversight bets that the protocol can close the gap — that between evenly matched debaters every lie carries an exposable flaw its opponent is paid to find, while the truth can always afford its own defence. It is a beautiful bet, with non-trivial theory and non-trivial doubts attached, and whether it pays — whether arguing, in any of this section’s four costumes, actually makes the answers truer — is not a matter for the theory at all. It is a matter for the ledger, and the ledger, pleasingly untidy, is next.
14.6 Does Arguing Make Agents Cleverer?
An audit needs ground rules before it needs evidence, and this one needs two. The first is the control that most published enthusiasm omits: matched budget. A debate consumes several agents’ worth of tokens over several rounds, so the honest baseline is never a single model answering once — it is the same spend allocated any other way: more samples majority-voted (Chapter 5’s self-consistency), a longer single deliberation, a bigger model consulted briefly. A comparison without that control cannot distinguish the virtue of arguing from the virtue of spending more, and much of the literature’s glow dims under it. The second rule is about the question itself. “Does debate help?” has the same defect as “do committees work?” — the answer is yes, no, and it depends, all reliably reproducible. The auditable question is when, and through which mechanism — and the chapter is now equipped to say something sharper than folklore, because both columns of the ledger below are real, and the theory of the last two sections predicts where each should apply.
14.6.1 The Case For
The strongest argument for external argument is the documented failure of the internal kind. Liang and colleagues gave the previous section’s complaint about self-critique a sharper name: degeneration of thought — once a model is confident in its answer, reflection stops producing novel considerations, however wrong the answer; confidence forecloses the very search that revision requires (2024). Their remedy was structural, and it is this chapter’s: stage a debate — agents obliged to disagree, “tit for tat”, before a judge — and answers that self-reflection could not reach become reachable, because a rival under instructions to attack is a source of considerations the agent would never have volunteered against itself. The multi-agent debate gains of the previous section (2024) sit in the same column and run on the same fuel: different instances stumble differently, and the exchange pools what no single pass contained.
The column’s headline entry, though, is the oversight experiment, because it tested the wager where it is hardest to win. Khan and colleagues built the information asymmetry deliberately — judges answering reading-comprehension questions without the text, debaters arguing opposite answers with access to it and to verified quotations — and found debate lifting weak LLM judges from 48% to 76% accuracy, and human judges from 60% to 88% (2024). Better still for Irving’s bet: optimising the debaters for persuasiveness raised the judges’ accuracy further, because more persuasive debaters improved at defending true answers faster than at defending false ones — skill, in that arena, favoured truth. It is one carefully built casino, but the house won exactly as the theory hoped, and the construction is instructive: claims checkable down to the quotation, an enforced information gap for pooling to close, and a zero-sum protocol nobody could decline to play.
14.6.2 The Case Against
The deflationary result is just as carefully built. Smit and colleagues benchmarked the going debate protocols against the boring baselines at comparable cost, and found that multi-agent debate, in its current forms, does not reliably outperform self-consistency and ensembling — while proving more sensitive to hyperparameters, so that the practitioner pays extra fragility for unproven gain (2024). Read alongside the matched-budget rule, the finding has a blunt moral: much of what debate appeared to buy was the ordinary return on sampling more than once, collectable without anyone exchanging a word. For a field fond of the pattern, it is an uncomfortable audit — the committee, it turns out, is frequently just an expensive way to take a poll.
The failure has mechanics, and every part is already familiar. Deliberation correlates errors: Chapter 13’s jurors (Section 13.5) were correlated enough through their shared weights, but at least they erred in private, each alone with its convictions; jurors who read one another’s answers import one another’s mistakes in real time — the correlation the ballot merely suffered, the conversation actively manufactures. The carrier is sycophancy (Sharma et al., 2023): models trained toward approval yield to confident pushback even when they were right, so a debate among sycophants is not an argument but a race to agree, and convergence — the very stopping criterion the pattern celebrates — becomes a social fact rather than an epistemic one. A single confident error can herd the panel, and the transcript that results is the most dangerous artefact in this chapter: a wrong answer with a documented defence. This is Chapter 13’s question returned with its answer — arguing reliably makes verdicts better-defended; it makes them better only when the judge can tell a defence from a truth.
14.6.3 The Verdict
Both columns are correct, and the jury theorem already priced the trade between them (Section 13.4): deliberation pools information and correlates errors in the same breath, and the sign of the net effect is not a property of “debate” — it is a property of the protocol and the question. Debate helps where pooling dominates: information asymmetric by construction, claims checkable at least in their atoms, a judge able to verify something — Khan’s casino, clause by clause. Debate hurts where correlation dominates: a homogeneous panel, unverifiable claims, a judge swayed by fluency — the sycophants’ séance, clause by clause. The practitioner’s question “should my agents debate?” is therefore malformed in a precise and useful way: it asks about a technique when it should ask about a regime, and the regime is decided by choices the practitioner controls.
Which yields, as a closing dividend, the design rules this chapter has been assembling all along. Independence before deliberation: collect committed answers before any agent reads any other, so the jury is banked before the pooling begins. Attacks earned, not asserted: an objection must carry its exhibit — the quote, the test, the trace — or wait until it can. Structure, not a group chat: roles, turn limits, and a stopping rule other than exhaustion or agreement. A judge with at least one power of verification, exercised routinely. And matched-budget evaluation as standing discipline: a debate that cannot beat the same tokens spent on silent sampling is not deliberation but theatre. Where these conditions cannot be met — no checkable atoms, no genuine information gap, a panel that is one model photocopied — the honest engineering decision is that arguing is the wrong instrument, however impressive the transcript.
And some conflicts are beyond every instrument this chapter owns, which is where it must end. Argument moves beliefs where evidence can bite; negotiation moves positions where packages can enlarge the pie; both run on the possibility that something can change. But when interests are fixed, valuations are private, and a scarce resource must simply go to whoever values it most — the team’s budget, at last, in the hardest case — more conversation extracts only more posturing, and every mechanism of this chapter hits the same wall: talk is cheap precisely where the stakes make honesty expensive. What is needed is a device that makes revealing one’s true valuation the best move — that gets the honest answer without asking anyone to be honest. That device exists, it is called a price, and designing the rules that make prices tell the truth is the subject of the next chapter.
14.7 Summary
- Negotiation is joint decision-making under mixed motives. The parties want different divisions and share an interest in agreeing at all; the surplus is real, the disagreement point anchors everything, and an agent’s true power at the table is its best alternative to a deal — which is why an agent that cannot credibly walk away is not negotiating but requesting.
- Interests and claims are different disagreements. Bargaining resolves conflicts over what agents want, where a deal is not a truth; argumentation resolves conflicts over what agents believe, where there is something to be right about. The split continues Chapter 13’s species distinction into conversation — and self-interested agents will dress the one as the other.
- Bargaining theory unites fairness and strategy. Nash’s axioms pick out a unique reasonable split; Rubinstein’s alternating offers show patient strategic haggling converging on essentially the same answer; and the strategic version prices the things agents actually have — patience, deadlines, and outside options — in a currency that token budgets make literal.
- Automated negotiation is protocol plus strategy. The classical programme — Rules of Encounter, monotonic concession, tactic families — showed that the rules of the encounter decide whether honesty and efficiency are individually rational, a lesson that points straight at mechanism design; a negotiating agent is only as trustworthy as the protocol that disciplines it.
- Argument has a formal theory, and it is graph theory. In Dung’s frameworks an argument’s acceptability is computed from the structure of attacks and defences, not from eloquence — the standing of a claim is a property of the graph. Engineers staging debates are running instances of this theory, mostly unread.
- Debate, critique, and adversarial collaboration are its newer clothes. Multi-agent debate is a dialogue game; the critic’s objection is an attack edge; the revision that survives review is an argument that survived its attackers — and debate-as-oversight schemes bet that arguing before a weaker judge amplifies truth rather than persuasiveness.
- The evidence on debate is genuinely mixed, and the jury theorem explains why. Deliberation pools information and correlates errors in the same breath: debate helps where pooling dominates — asymmetric knowledge, checkable claims, a judge able to verify — and hurts where correlation does, as fluent confidence herds the panel to a well-defended wrong answer. Structure, not enthusiasm, decides which regime a system is in.
- Talk is priced in tokens, and some conflicts outrun it. Negotiation and argument are worth their considerable cost where positions can genuinely move; where interests are fixed and scarce resources must simply be divided, the honest instrument is not a longer conversation but a price — which is Chapter 15.
14.8 Exercises
Exercise 1. The orchestrator needs a schema migration done. Doing it in-house would cost 42,000 tokens of the team’s budget; an external migration service can deliver it at a true cost to itself of 30,000 tokens; the two negotiate a price, in tokens, for the job. (a) State each party’s reservation value and what fixes it, the zone of possible agreement, and the surplus that agreement creates; then, taking both utilities linear in tokens and the situation otherwise symmetric, show that the Nash bargaining solution of Section 14.2 prices the deal at the midpoint of the zone, and compute the price and each side’s gain. (b) Before talks open, the orchestrator could spend 2,000 tokens on a fallback spike that would cut the in-house cost to 32,000. Recompute the predicted price and the orchestrator’s total outlay, and compare with spending the same 2,000 tokens polishing the arguments it will make at the table; then rework the sums for a stronger spike that cuts the in-house cost to 29,000 — what happens to the zone, what does the orchestrator’s best outcome now look like, and why does Section 14.1 count this dead negotiation as the machinery working? (c) The service opens with “our floor is 40,000; we could not possibly go lower.” Compute what the claim is worth to the service if the orchestrator credits it, explain why it is cheap talk in the sense of Section 12.5, and say what makes the spike-holding orchestrator’s threat to walk away credible in the sense of Section 12.3 when the service’s floor-claim is not.
Exercise 2. A sprint closes with 12,000 unspent tokens, which return to the platform unless the coder and tester agree on a division — so the disagreement point is d = (0, 0). The coder values tokens linearly, u_c(x) = x; the tester, whose starved regression suite makes the first tokens matter most, has u_t(y) = \sqrt{y}. (a) Using the maximiser of Section 14.2.3, derive the Nash bargaining division by calculus and give both token shares and both utilities. (b) The tester remeasures its satisfaction as 3\sqrt{y}; recompute, and name the axiom whose work you have just watched. (c) Show that a utilitarian rule — maximise the sum u_c + u_t — awards the tester \frac{1}{4} of a token, and \frac{9}{4} under the remeasurement of (b); conclude in one sentence why no sum-based rule can satisfy scale invariance. (d) Recompute the division with both utilities linear, and reconcile the answers of (a) and (d) with Section 14.2’s claim that the party whose utility drops steeply toward the disagreement point is awarded less of the surplus — then say what that pricing implies for an agent whose prompt announces to the table how badly it needs the deal.
Exercise 3. The orchestrator (party 1) and an external review service (party 2) bargain by alternating offers over a 12,000-token surplus under the discounting of Section 14.2.3: a round of haggling costs the orchestrator 20 per cent of the remaining value (\delta_1 = 0.8), while the service, whose reserved compute slot is bleeding away, loses half (\delta_2 = 0.5). (a) Derive x^{*} = (1 - \delta_2)/(1 - \delta_1 \delta_2) from the stationarity pair — each proposer offers its counterpart exactly the discounted value of what that counterpart would take as next round’s proposer — and confirm by differentiation the chapter’s comparative statics: the proposer’s share rises with \delta_1 and falls with \delta_2. (b) Compute both parties’ token takes when the orchestrator proposes first and when the service does; separate what patience buys from what proposing first buys. (c) With equal patience \delta_1 = \delta_2 = 0.8, compute the proposer’s take, and say what happens as \delta \rightarrow 1 and which reunion of Section 14.2 that limit is. (d) A hard sprint deadline drops the orchestrator’s effective discount factor to 0.4: recompute its take as proposer and price the shortened leash in tokens; then explain what the loss presupposes about who can see the deadline, and what re-enters the model — and why — once discount rates are private rather than common knowledge.
Exercise 4. Sprint planning has produced five package deals trading tokens now against tokens next sprint and risky work against safe — the integrative bundles of Section 14.1 — with utilities, written (coder, tester) and deadlock worth zero to both: A (10, 2), B (8, 5), C (6, 7), D (4, 9), E (1, 10). Coder and tester negotiate under the monotonic concession protocol with the Zeuthen strategy of Section 14.3, each opening at its favourite package and conceding one package at a time. (a) Compute every package’s Nash product and name the Nash bargaining point. (b) Run the protocol by hand: each round, give both risk-willingness ratios as exact fractions, name the conceder, and verify that the single-package concession does tip the balance the other way; stop at agreement and confirm it lands on the Nash point. (c) Implement the run, then rerun it on the deal set with the never-chosen package D deleted, and again with C deleted; report both agreements, and say which of Nash’s four axioms the first rerun exhibits operating as a protocol property, and why the second rerun is no counterexample to it. (d) Prove that r_i is unchanged by rescaling u_i \rightarrow \lambda u_i for any \lambda > 0, conclude exactly what an agent gains by announcing its stakes in louder units, and name the kind of misreport the protocol remains exposed to — and why Section 14.1’s private types make that exposure structural rather than a bug.
Exercise 5. The team’s purchasing agent (the buyer) and an external GPU-broker agent (the seller) negotiate the price of a fine-tuning slot: the seller’s floor is 30,000, the buyer’s ceiling 42,000, their opening books 48,000 and 24,000, and the deadline T = 20 rounds. Each round both post simultaneous offers from the time-dependent family of Section 14.3, conceding from ideal to reservation along \alpha(t) = (t/T)^{1/\beta}; the deal executes in the first round the buyer’s offer at least meets the seller’s, at the mean of the two standing offers. Take boulware \beta = \frac{1}{4} and conceder \beta = 4, the profiles of Figure 14.2. (a) Implement the exchange and tabulate the deal round and price for all four pairings of the two profiles. (b) Explain the table’s pattern — who captures the zone against whom, and what the symmetric pairings pay for their symmetry — and state which lesson of Section 14.2 the mixed pairings re-derive without an equilibrium in sight. (c) Now charge each party 150 tokens per round of haggling and recompute the four pairings’ net surpluses; identify the party that ends worse off than never having come to the table, explain how a tactic blind to its own burn rate managed that, and name the Faratin tactic family whose job is to prevent exactly this. (d) Halve the buyer’s deadline to T_b = 10 — its curve anchors there, so it offers its full reservation from round 10 on — leaving the boulware seller at T = 20: recompute the boulware–boulware pairing, and price Section 14.2’s warning that a visible deadline is handing the other side its knife.
Exercise 6. One maintenance chore — rebuilding the flaky-test quarantine list, effort 900 tokens — must fall to somebody each sprint, and the orchestrator’s rule \mathrm{R}_1 assigns it to whichever of coder and tester declares the lighter backlog; a declaration is a 50-token board message, and nothing checks it. True backlogs this sprint: coder 6,000, tester 5,000. (a) Show that padding its declaration is rational for the tester and compute the gain; explain why a system-prompt homily — “always report your workload honestly” — changes nothing in the calculus; and say what happens to the informational value of every declaration once both agents reason this way, restating in one sentence the verdict of Section 14.3 on whether agents lie. (b) The orchestrator adds an audit: each declaration is checked against the run journal with probability q, at 120 tokens per check, and a detected pad earns the chore plus a 2,000-token budget penalty. Derive the condition for padding to remain profitable (mind that the 50-token declaration is paid under honesty and padding alike), show the deterrence threshold is q^{*} = \frac{9}{29} \approx 0.310 — and that three audits in ten therefore fall thirty tokens short of deterring — and compute the standing price of deterrence at q = \frac{1}{3} against the price of the chore. (c) Redesign the encounter: give one concrete rule \mathrm{R}_2 under which the incentive to pad evaporates rather than being policed, state the property of \mathrm{R}_2 that does the work and the price paid for it, and say what the end-to-end negotiators of Section 14.3 — which learnt to feign interest with nobody having suggested it — would learn under \mathrm{R}_1, and why the general design of such rules is Chapter 15’s subject rather than a prompting problem.
Exercise 7. The review thread of Section 14.4.3 grows two limbs. To \mathcal{A} = \{P, R, B, T\} with \mathcal{R} = \{(R, P), (B, R), (T, B)\}, add the tester’s second objection S: “the benchmark shows a 20 per cent latency regression” — an attack on P; the coder’s reply N: “the benchmark host was contaminated; the regression is an artefact” — an attack on S; and the tester’s counter M: “the contamination report used the wrong manifest” — where N and M attack each other, each side calling the other’s evidence the artefact. (a) Iterate the defence function \mathcal{D} from the empty set by hand, one line per step, to the grounded extension; classify every argument as accepted, rejected (attacked by the extension), or left undecided. (b) Find every preferred extension, justifying maximality, and classify each argument as sceptically accepted, credulously accepted only, or in no admissible set; state the merge verdict under each standard, and explain why the two standards agree about P but part over S. (c) Extend the companion module foundations/algorithms/argumentation.py — whose docstring leaves preferred extensions “deliberately” to this chapter’s exercise — with preferred(A, R_attacks), built by subset enumeration over its is_admissible test; check it against (a), (b), and the four-node chain of Section 14.4.3, and say why brute force is forgivable at seven arguments and doomed at sixty. (d) Prove what your code exhibits: show that \mathcal{D} is monotone, deduce by induction that every fixed point of \mathcal{D} contains \mathcal{D}^{k}(\emptyset) for all k, and conclude that the grounded extension is contained in every preferred extension — taking as given Dung’s fundamental lemma, that an admissible set which defends a stays admissible when a joins, from which a maximal admissible set is a fixed point of \mathcal{D}. (e) The tester reruns the benchmark on a fresh host from a pinned manifest and reproduces the regression — a new argument V attacking N, earned by execution in the sense of Section 14.4. Recompute both semantics, describe what the earned attack bought, and show what happens if the coder’s costless reply “the rerun is contaminated too” is admitted as an attack on V — and what that says about letting arrows into the graph for the price of asserting them.
Exercise 8. On the coder’s stream-parser patch the reviewer raises three objections: O_1, “this parser is too convoluted; split it before it merges”; O_2, “this will crash on an empty batch — the loop body assumes at least one record”; and O_3, “the variable names are misleading”. The coder renames the variables, adds a source comment reading “complexity acknowledged, refactor deferred”, and answers O_2 with “the scheduler guarantees batches are non-empty, so that case cannot arise”. The reviewer replies “the naming and complexity points are addressed — approving”; the patch merges; a fortnight later production crashes on an empty batch during a queue drain. (a) Write the exchange as an argumentation framework twice — once as the reviewer acted on it, once honestly — marking every attack edge earned or merely asserted (Section 14.4); compute the grounded extension of each, show that the first endorses shipping and the second does not, and say precisely which two edits turned the second graph into the first. (b) Diagnose the drift Section 14.5 warns of: which moves were concessions traded rather than attacks answered, what a commitment store would have shown against O_1 and O_2 at the moment of approval, and what the stopping rule “the critic runs dry” actually measured in this transcript. (c) Redesign the loop so the failure cannot recur: say which of O_1–O_3 can be earned into evidence-backed attacks at all, and by what exhibit; give the ship gate as a property of the framework; give a stopping rule that is neither exhaustion nor agreement; add one guard against a placated critic; and name the row of Table 14.2 your rebuilt loop now most resembles, defending the choice.
Exercise 9. Price the audit of Section 14.6. A committed answer costs 1,000 tokens; a solo pass is correct with probability 0.7, errors independent across passes; the run’s budget is 9,000 tokens. The silent discipline buys nine samples and a majority vote; the debate buys three debaters for three rounds at 1,000 tokens per debater per round (answers are short; take the round cost as flat). Model the debated verdict as the chapter describes it: with probability h the panel herds on its most confident member, correct with probability 0.6 — confidence being no calibration — and otherwise the three vote independently, each lifted by the exchange to accuracy p'. (a) Compute the silent baseline P_9 exactly. (b) For modest pooling, p' = 0.78 with h = 0.3: compute the debate’s accuracy; then set h = 0 and show the debate still loses — name the finding of the chapter’s case against that this arithmetic reproduces, and say what the committee turns out to be. (c) For strong pooling, p' = 0.9: compute the accuracy at h = 0.3, then find the herding threshold h^{*} below which the debate beats the silent baseline. (d) Show that at h = 0.3 no p' \le 1 rescues the panel, and compute the herding ceiling at which even debaters made infallible by the exchange break even; then say which two of the chapter’s closing design rules these two thresholds price, and why “should my agents debate?” is, on this arithmetic, a question about a regime rather than a technique.
Exercise 10 (lab). Put live models at Rubinstein’s table. Two model instances bargain over 100 compute credits by alternating offers, at most six rounds, both getting nothing on no deal; each round of delay shrinks the pie’s worth by 20 per cent for the impatient side (\delta = 0.8) and 2 per cent for the patient side (\delta = 0.98); the briefs state the protocol exactly, and who opens is balanced across trials. (a) Before any model runs, compute the benchmark: the subgame-perfect split of this six-round game by backward induction from the last round, for both orders of proposal, and the infinite-horizon shares of Section 14.2.3 for contrast — then say which matters more at this horizon, patience or holding the last proposal. (b) Run at least ten negotiations per condition: (i) symmetric decay, 2 per cent each; (ii) asymmetric, both parties briefed on both rates; (iii) asymmetric, each briefed only on its own rate. Record opening demands, agreed splits, rounds to agreement, and the no-deal rate; then compare (ii) against the benchmark and (iii) against (ii): does disclosure move the split the way Section 14.2 prices, does either side capture anything like the equilibrium share, and does haggling persist where the theorem says the first offer should close? (c) Add the valuation harness: three issues — GPU-hours, review-priority slots, CI minutes — with asymmetric private per-unit values in the briefs; the agents chat freely, then submit a binding allocation. Count the runs in which an agent’s stated valuations diverge from its brief, and separately the feints — professed interest in the issue it values least, the better to trade it away — that the end-to-end negotiators of Section 14.3 discovered unprompted. Record the model identifier and the date beside every table: the rates are perishable, and the durable findings are the direction splits move under disclosed patience, the distance between fluent behaviour and equilibrium, and whether feigning appears without being taught.
Exercise 11 (lab). Audit the debate yourself. Assemble a bank of at least thirty objective questions with mechanically checkable answers — short arithmetic word problems, or queries against a repository the agents can read. Run three arms at matched measured token spend, using the provider’s usage accounting rather than estimates: (i) silence — k independent samples and a majority vote, k set (odd) to match the debate arm’s realised spend; (ii) debate — three instances answer independently, their committed answers are logged before any agent sees a rival’s, then two revision rounds with sight of the others’ answers, and a final majority vote (the logged first round is a free fourth arm: the banked jury that Section 14.6’s first design rule demands); (iii) sabotage — debate as in (ii), except one seat is scripted to open with a confidently wrong answer defended by fabricated detail. Report, per arm: accuracy; error correlation, measured as the excess of the panel’s pairwise joint-error rate over the product of the individual error rates; and, for the sabotage arm, the flip rate — the fraction of items on which a debater that was right at commitment finishes on the saboteur’s answer. Read the results against Exercise 9: which regime is your panel in, and what does the flip rate say about h? Record the model identifier and the date; the durable finding is the ordering of the arms and the sign of the correlation the conversation manufactures, not any absolute rate.