%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#E8ECFF", "primaryBorderColor": "#4054B2", "primaryTextColor": "#16171B", "lineColor": "#3B4351", "edgeLabelBackground": "#FAF7F0", "clusterBkg": "#EFE9DC", "clusterBorder": "#766F65"}}}%%
flowchart BT
A["Coalition<br/>held by payoffs alone"]
B["Organisation<br/>roles, authority,<br/>reporting lines"]
C["Institution<br/>the rules of the game,<br/>formal and informal"]
T["durability ↑<br/>flexibility ↓"]
A -->|"add authority"| B
B -->|"add sanction"| C
C -.->|"frames what is<br/>rational below"| A
classDef inst fill:#E8ECFF,stroke:#4054B2,color:#16171B,stroke-width:2.5px
classDef world fill:#EFE9DC,stroke:#766F65,color:#16171B
class C inst
class T world
16 Coalitions, Organisations, and Institutions
Since Chapter 10 this book has leaned, nearly every page, on a word it has never once inspected: the team. Part III equipped the team to cooperate; Part IV taught its members to vote, haggle, argue, and bid; but the team itself arrived as a fait accompli — four agents, conveniently assembled, conveniently loyal, conveniently four. Nobody asked why these agents work together and not some other set; whether the tester might do better hiring itself out to a rival orchestrator; why the reviewer does not demand a larger share of the budget on pain of leaving; or what, exactly, would happen to the enterprise if it did. The last chapter ended with Coase’s observation that the cheapest institution is often to stop being strangers. This chapter asks everything that observation defers: which alliances form and which do not, what each member can demand for staying, what turns a huddle of the willing into a structure that survives its members’ moods — and what any of it has to do with four language models wearing job titles.
The chapter climbs a ladder, and the ladder is its table of contents. A coalition is an alliance held together by nothing but its payoffs: worth joining while the numbers say so, gone when they stop. An organisation is a coalition made durable — roles, authority, and reporting lines that persist while individual members come, go, and misbehave. An institution is what outlasts even the organisation: the rules of the game themselves, formal and informal, that shape what every coalition and organisation finds rational in the first place. Each rung trades flexibility for permanence, and each has its own theory. The coalitional rung comes with genuine mathematics — the two questions of who joins whom and who gets what turn out to have exact and sometimes startling answers — and the reader is owed advance notice of a delicious fact: the fairness half of that mathematics, worked out in 1953 for dividing a coalition’s spoils, is now executed millions of times a day inside explainability toolkits, under the name of a Shapley value, to answer the question of which feature deserves credit for a model’s prediction. The theory of fair division became the theory of credit assignment while nobody was looking, and for teams of agents it is both at once.
The pedigree, as ever, precedes the agents — and this time it precedes even the game theory the reader already knows. Von Neumann and Morgenstern devoted the greater part of their founding 1944 volume to coalitional games; Shapley supplied the fair-division value in 1953, and the core — the set of divisions no sub-alliance would secede from — crystallised in the same remarkable Princeton circle. Organisation theory grew up alongside: Simon, whose bounded rationality the reader met in Chapter 12, earned his Nobel arguing that organisations exist to do what bounded individual minds cannot — and North earned his for the institutional rung of the ladder. Multi-agent systems research embraced all three rungs with particular enthusiasm — coalition formation algorithms, organisational self-design, electronic institutions, computational trust — to the point of sustaining a workshop series named, in full, Coordination, Organizations, Institutions and Norms. The material is abundant, classical, and largely unread by the engineers it now concerns, which is where the preface’s bluntest promise falls due: giving four agents the titles Chief Executive, Architect, Developer, and Reviewer does not, by itself, produce an organisation. This chapter is where the difference between a job title and a coordination mechanism is spelled out in full.
Two stipulations, and a farewell. First, the money of Chapter 15 mostly stays: coalitional theory in its standard form assumes value is transferable — spoils that can be divided — which fits token budgets admirably and fails, as before, where it fails. Second, enforcement now comes in grades and the grading matters: a coalition must be self-enforcing (nothing holds it but the payoffs), an organisation adds authority, and an institution adds sanction — with the harness, as usual, offering the designer options human societies lack, including making violations impossible outright rather than merely expensive. And this chapter closes Part IV: what began in Chapter 12 with two prisoners in separate cells ends here with agents founding companies. We proceed from the coalitional game and the question of who joins whom (Section 16.1); to dividing the spoils — the core, the Shapley value, and the latter’s second career (Section 16.2); to organisations and what a role must actually do to be real (Section 16.3); to norms and institutions, the rules of the game themselves (Section 16.4); and finally to trust, reputation, and the price of a name — the institution that lets strangers deal at scale, and the close of the whole part (Section 16.5).
16.1 Joining Forces: The Coalitional Game
Game theory as Chapter 12 presented it takes the individual as its unit: one player, one strategy set, one payoff, and everything social emerging — or failing to — from the collisions. Coalitional game theory — cooperative game theory, in the literature’s more common name, and a field with textbooks of its own (Chakravarty et al., 2015) — is the older branch, and it starts from the other end. Its unit is the coalition: a set of players acting as one, and the theory’s founding abstraction is as severe as any this book has met. Ignore how a coalition coordinates — the plans, the protocols, the commitments, the whole apparatus of Part III — and record only what it can achieve: for every possible subset of players, a single number. Von Neumann and Morgenstern, who built the theory in the founding text of the entire subject, considered this the natural viewpoint and lone strategising the special case (1944); the field spent the next half-century inverting their emphasis, but for anyone who assembles teams for a living, the original orientation is the useful one. The question is not what one agent should do. It is what a group is worth.
The machinery is one definition deep. A characteristic function assigns to every subset S of the agents a value — what S could guarantee for itself by cooperating internally, whatever everyone outside S chooses to do — and the standard theory assumes this value is transferable: spoils that can be divided among the members in any proportion, which a token budget satisfies to the penny. The whole of Part III is thereby filed, without apology, under one number per team. For the book’s running four: the coder alone ships some fraction of the task suite; coder and tester together ship more, and more than their solo sum, since bugs caught early stop being rework; the full quartet, pipeline complete, scores highest of all. Write those numbers down for all sixteen subsets and the team stops being an anecdote and becomes a game — an object about which the theory can prove things.
The first thing it proves cuts in favour of merging. Call a game superadditive when any two disjoint coalitions are worth at least as much merged as apart — plausible on its face, since a merged coalition can always operate as two separate ones under a single flag and pocket whatever coordination adds. Under superadditivity the arithmetic points one way: the grand coalition of everyone, the largest pie there is. And here the theory earns its first engineering scepticism, because every practitioner knows teams that got worse as they got bigger. The resolution is that real characteristic functions are frequently not superadditive: coordination has a price (Section 11.6), context dilutes, interfaces multiply — and the definitive statement predates multi-agent systems by decades. Fred Brooks’s law — adding manpower to a late software project makes it later (1975) — is, in this chapter’s terms, an empirical claim about the shape of software’s characteristic function: past a certain size, v turns over and additional members subtract. (This is a different Brooks from Chapter 2’s roboticist, though their laws share a certain scepticism about adding more of anything.) Whether a given team’s value function is superadditive is not a matter of doctrine; it is a measurable property with a maximum, and the maximum, not the merger instinct, should size the team.
Even where merging genuinely pays, the grand coalition is not guaranteed, and the reason previews the next section: a coalition forms only if its members can agree how to divide what it wins. A bigger pie that cannot be sliced agreeably loses to a smaller one that can, so the theory’s two questions — who joins whom, and who gets what — are not sequential but simultaneous, and answering the first requires the second. The formation question also has a purely computational face, and it is a hard one. Partitioning agents into working groups to maximise total value — coalition structure generation — ranges over every way of splitting the population, a number that grows so fast that twenty agents already admit some fifty trillion partitions; the problem is NP-hard, and no amount of cleverness will make the general case cheap. What cleverness can do is bound the damage: Sandholm and colleagues showed that searching a small, carefully chosen fraction of the space yields a solution provably within a known factor of optimal (1999), and two decades of algorithmic refinement followed (Rahwan et al., 2015). The engineering translation deserves italics: an orchestrator that groups agents into sub-teams is doing coalition structure generation, usually greedily, always without guarantees — one more entry in the preface’s ledger of theory re-derived by folklore.
One feature of the agent setting, though, changes the theory’s practical standing entirely, and it is worth savouring. For human coalitions — firms, cartels, cabinet governments — the characteristic function is a modelling fiction: nobody can rerun a merged company against its unmerged counterfactual. For a team of agents, v(S) is an empirical object: take the subset, run it on the benchmark suite, record the score. The counterfactuals that economics can only assume, a harness can execute — every subset, if the budget allows, since there are only 2^n of them and the exponential is affordable at team scale even where it is ruinous at population scale. This is the Gode–Sunder discipline of Section 15.4 extended from mechanisms to memberships: measure what each arrangement is actually worth before theorising about it. It also means the classical theory lands here with unusual traction — its central object, a fiction for seventy years, is for agent teams a weekend of evaluation runs.
Knowing what every subset is worth, however, answers only half of the double question. The four agents can see, in the numbers, that the full pipeline beats every fragment; what the numbers do not yet say is what the tester can demand for staying — and whether any division of the spoils exists that keeps every faction content at once. That question has two celebrated answers, one about stability and one about fairness, and they do not always agree with each other. They are the next section’s business.
16.2 Dividing the Spoils: The Core and the Shapley Value
A theory of division must first decide what it is for, and it turns out there are two defensible answers. One can ask of a proposed split that it hold — that no faction, consulting the characteristic function, finds it profitable to walk out — or one can ask that it be just — that each member receive what its presence is actually worth. Stability and fairness sound like the same demand said twice, and the enduring surprise of coalitional game theory is that they are not: they have different mathematics, different champions, and no general obligation to agree. The stability answer is called the core; the fairness answer is called the Shapley value; and an engineer allocating a team’s budget is, knowingly or not, taking a side.
16.2.1 The Core
An allocation of the grand coalition’s value is in the core — the concept was isolated by Gillies, a Princeton contemporary of Shapley’s — when every subset of agents receives, in total, at least what it could earn by seceding: for all S, the members of S are paid at least v(S). Nothing subtler than that, and nothing weaker will do, because any coalition paid less than its outside worth has, by the book’s now-standard logic, a credible threat to leave — and Section 16.1 established that for agent teams the outside worth is not a rhetorical flourish but a measurable number. A core allocation is therefore a peace treaty with every possible faction at once: the tester’s demand for a larger share is bounded by what tester-including coalitions could actually earn elsewhere, and a division in the core prices every such threat simultaneously. When one exists, the grand coalition can stand on economics alone — no loyalty oaths required.
The difficulty is that sometimes none exists, and the smallest counterexample deserves to be worked in full. Three agents; a bounty of 300 tokens; any two of them can complete the job and claim it all, a third adding nothing. Consider any division — say an equal hundred each. The coder and tester, between them holding 200, notice that alone they could take the full 300; they defect and split it 150 apiece. But now the reviewer, holding nothing, offers the tester 160 to form a new pair; the tester agrees; the coder, abandoned, counter-offers the reviewer… and the music never stops. Every division leaves some pair short of the 300 it could seize, so every division carries the seed of its own overthrow: the core is empty, the cycling is eternal, and — the point to underline — nothing is wrong with the negotiators. Some situations are structurally unstable, and no protocol, prompt, or plea will settle what the characteristic function has made unsettleable.
%%{init: {"theme": "base", "themeVariables": {"primaryColor": "#E8ECFF", "primaryBorderColor": "#4054B2", "primaryTextColor": "#16171B", "lineColor": "#3B4351", "edgeLabelBackground": "#FAF7F0", "clusterBkg": "#EFE9DC", "clusterBorder": "#766F65"}}}%%
flowchart TD
CT["Coder + Tester win 300<br/>reviewer shut out"]
TR["Tester + Reviewer win 300<br/>coder shut out"]
RC["Reviewer + Coder win 300<br/>tester shut out"]
CT -->|"reviewer lures tester"| TR
TR -->|"coder lures reviewer"| RC
RC -->|"tester lures coder"| CT
Both failure modes matter to the practitioner, because the core can disappoint in two opposite directions. Where it is empty, coalition churn is a property of the task’s economics, and the remedy is not exhortation but redesign — change the values, change the game. Where it is non-empty it is often wide: a whole range of divisions, from the tester-favouring to the tester-fleecing, all equally stable, about which the theory simply shrugs — stability, it turns out, constrains without choosing. And for agent teams the diagnosis is actually runnable: the core is defined by one inequality per subset, 2^n in all, every term measurable by Section 16.1’s ablation runs — so whether a team’s economics are stable, fragile, or indeterminate is not a seminar question but a report an orchestrator could generate. What stability cannot do, even in the best case, is tell anyone what a fair division would be. For that the theory keeps a separate instrument.
16.2.2 The Shapley Value
Shapley asked the fairness question the way this book’s readers will now expect it to be asked: not “what feels fair?” but “what properties must any fair division rule have — and how many rules have them?” (1953). Four properties, each hard to argue with: the rule should share out exactly the grand coalition’s value, no more, no less; interchangeable agents — identical marginal contributions everywhere — should receive identical shares; an agent that adds nothing to any coalition should receive nothing; and the rule should respect addition, valuing a composite of two independent games at the sum of its parts. The theorem is that exactly one rule survives, and it has a form a working engineer can love. Imagine the team assembling one agent at a time, in random order; as each walks in, credit it with the value its arrival adds; then average that credit over all n! possible orders of assembly. Your share is what you add, averaged over every story of how the team might have come together — the Shapley value, and one more instance of the book’s favourite manoeuvre: the axiomatic method walking into a crowded room of candidate answers and leaving with just one (Section 13.3 gave the dismal version; Section 14.2’s bargaining solution the cheerful one).
Its virtues and its limit are both instructive. Unlike the core it always exists and is always unique — the fair answer never cycles and never shrugs. But fairness purchases no stability: the Shapley division can sit outside a perfectly good core, fair and doomed at once, and it exists serenely in games whose core is empty, prescribing a just split that some pair will immediately overturn. Stability and fairness are simply different virtues, and a division can have either without the other — which is why the section needed two instruments, and why an engineer must decide whether the budget’s division is meant to keep the peace or to reward contribution, because the theory has now said, precisely, that these can be different numbers. (Shapley did eventually collect a Nobel — characteristically, for a different result entirely.)
16.2.3 The Core and the Shapley Value, Formally*
Fix the agent set N = \{1, \dots, n\}. A characteristic function is a map v : 2^{N} \to \mathbb{R} with v(\emptyset) = 0, assigning to every coalition S \subseteq N the value it can guarantee by cooperating internally, and the game is superadditive when v(S \cup T) \ge v(S) + v(T) for all disjoint S, T \subseteq N — merged, two coalitions are worth at least their sum. An allocation is a vector x \in \mathbb{R}^n, agent i receiving the share x_i, and an allocation lies in the core when it shares out exactly the grand coalition’s value and pays every coalition at least its outside worth,
\mathrm{core}(v) \;=\; \left\{ x \in \mathbb{R}^n : \sum_{i \in N} x_i = v(N) \;\text{ and }\; \sum_{i \in S} x_i \ge v(S) \;\text{ for all } S \subseteq N \right\},
one budget equality and 2^n secession inequalities. The Shapley value pays agent i its marginal contribution averaged over the n! orders in which the team might assemble; grouping those orders by the coalition S that i’s arrival finds already present gives the closed form
\phi_i(v) \;=\; \sum_{S \subseteq N \setminus \{i\}} \frac{|S|!\,(n - |S| - 1)!}{n!} \,\bigl( v(S \cup \{i\}) - v(S) \bigr),
in which the coefficient is exactly the fraction of the n! arrival orders that find S assembled and i next through the door. Shapley’s theorem is that \phi is the only rule with the four properties listed above: it shares out exactly v(N); interchangeable agents receive identical shares; an agent that adds nothing to any coalition receives nothing; and it values a composite of two independent games at the sum of its parts.
The 300-token majority game above now settles its own fate in one line of arithmetic. With v(S) = 300 for every coalition of two or more agents and v(S) = 0 otherwise, a core allocation would need x_1 + x_2 \ge 300, x_1 + x_3 \ge 300, and x_2 + x_3 \ge 300; adding the three gives 2(x_1 + x_2 + x_3) \ge 900, hence a total of at least 450 — and the grand coalition has only v(N) = 300 to distribute. The inequalities cannot all hold: the core is empty, exactly as the cycling exhibited.
The closed form, for its part, is as executable as it is exact: transcribe the coefficient factorial for factorial — s standing in for |S| — and the function is a dozen lines of standard-library Python, applied here to the game whose core has just been proved empty,
from itertools import combinations
from math import factorial
def shapley(v: dict[frozenset[str], float],
agents: list[str]) -> dict[str, float]:
n = len(agents)
phi = {}
for i in agents:
rest = [j for j in agents if j != i]
phi[i] = sum(
factorial(s) * factorial(n - s - 1) / factorial(n)
* (v[S | {i}] - v[S])
for s in range(n)
for S in map(frozenset, combinations(rest, s)))
return phi
agents = ["coder", "tester", "reviewer"]
v = {frozenset(S): 300.0 if len(S) >= 2 else 0.0
for r in range(len(agents) + 1) for S in combinations(agents, r)}
shapley(v, agents) # -> {'coder': 100.0, 'tester': 100.0, 'reviewer': 100.0}and the hundred apiece arrives pre-certified: symmetry forces the three shares equal, efficiency forces their sum to 300, so the axioms fix the output before the interpreter starts — the run checks the transcription, not the theorem. Note, too, where the expense sits. The sum ranges over the same 2^n coalitions that Section 16.1’s ablation runs must price, but a benchmark run costs real tokens and a dictionary lookup costs none: once v is on file, the fair division comes free.
16.2.4 Shapley’s Second Career
In 2017 the formula acquired a second life so vigorous that many of its current users have no idea it had a first. Lundberg and Lee, surveying the crowded field of methods for explaining a complex model’s predictions, showed that six of them were groping toward the same object, and that the object was Shapley’s (2017): treat the features as players, define v(S) as the model’s expected output when only the features in S are known, and the unique attribution satisfying their axioms is the Shapley value of that game. The resulting framework, SHAP, now runs inside explainability pipelines across finance, medicine, and engineering — a 1953 division-of-spoils formula, evaluated more times before breakfast than in its first sixty years, crediting features instead of players and with nobody at the table aware there was ever a table.
For agent teams the second career closes a loop, because the formula returns to its original cast. Let the players be the agents and let v(S) be the ablation benchmark of Section 16.1, and the Shapley value answers the question every multi-agent postmortem asks — which agent earned its tokens? — with the only division that satisfies the axioms. The comparison that shows why it beats the obvious alternative is worth spelling out. Leave-one-out — remove each agent, measure the drop — is the intuitive audit, and it fails in both directions. Give the team two agents that can each cover the same subtask, and leave-one-out awards both of them nothing — remove either and the other covers — although removing the pair collapses the pipeline; redundancy reads as worthlessness. Give it two agents that are jointly essential and individually useless, and each removal is catastrophic, so leave-one-out’s blame sums to far more than the team ever earned. The Shapley calculation, averaging over every order of assembly, splits the redundant pair’s shared credit between them and prices the complementary pair’s partnership correctly — because it is not a perturbation heuristic but the unique answer to the question the audit was trying to ask.
| Team structure | Leave-one-out verdict | Where leave-one-out goes wrong | Shapley verdict |
|---|---|---|---|
| Redundant pair — two agents each covering the same subtask | Both credited nothing: remove either and the other still covers | Under-counts: removing the pair collapses the pipeline, yet redundancy reads as worthlessness | Splits the shared credit between them |
| Complementary pair — two agents jointly essential, individually useless | Both blamed heavily: each removal is catastrophic | Over-counts: the blame sums to far more than the team ever earned | Prices the partnership correctly |
The price is the usual one in this chapter: exactness costs an exponential — all 2^n coalition values, all n! orderings — and the standard remedy is the usual one too: sample random arrival orders and average, a Monte Carlo estimate that converges respectably and underlies every practical SHAP implementation. At team scale the point is friendlier still: for four agents, exact Shapley is sixteen benchmark runs, and the fair audit is an afternoon. Credit assignment computed this way feeds forward twice — to Chapter 17, where a learning agent’s reward is itself a credit-assignment signal, and to Chapter 24, where evaluating multi-agent systems is the business at hand. But within this chapter its work is done: the theory can now say what every subset is worth, whether any division can hold, and what each member deserves. What it cannot yet say is why the team should still exist next week — why the coalition of the willing should acquire roles, memory, and a structure that outlasts this sprint’s payoffs. That is the ladder’s next rung.
16.3 More Than Job Titles: Organisations
A coalition, however cleverly divided, is glued together by nothing but its current arithmetic: recompute the payoffs after a bad sprint and the alliance may simply not be there on Monday. Yet the striking fact about real collectives — firms, faculties, regiments, open-source projects — is that they persist through arithmetic that should dissolve them, surviving bad quarters, departed founders, and members who have individually concluded they could do better elsewhere. Something more than the characteristic function is holding them up. Coase supplied half the answer at the end of the last chapter: the boundary exists because pricing every exchange costs more than administering it. But Coase explains why there is an inside without explaining why the inside is organised — why it has roles, ranks, procedures, and reporting lines rather than an undifferentiated pool of generalists. That question has its own classical answer, and its author is already a familiar figure in this book.
Herbert Simon’s account, built out with March into the founding text of organisation theory, locates the reason in the heads of the members: minds are bounded — the bounded rationality of Chapter 12, here in its original habitat — and organisations exist largely as prosthetics for limited minds (1958). Structure economises the scarcest resource in the building, attention. A role narrows what its occupant must consider from everything to a jurisdiction; a procedure makes a recurring decision once, well, and then replays it cheaply forever; a default absorbs the thousand choices nobody can afford to deliberate. The organisation, March and Simon argued, does not make its members’ decisions; it shapes the premises of those decisions — what each member sees, assumes, and treats as settled. For language-model agents the theory lands with unusual directness, because their boundedness is not a psychological postulate but a line on a specification sheet: a context window is a bound on attention, and Chapter 7’s whole apparatus of memory and retrieval is boundedness management. Organisation, in Simon’s sense, is context engineering by other means — deciding, structurally and in advance, what each mind will be asked to hold.
Say precisely what the structure consists of, because the word “role” is about to do heavy lifting. A role is a standing bundle of three things: an information flow (what its occupant sees, and what it must pass on), an authority (what it may decide or do without asking), and an accountability (what it must answer for, to whom, when things go wrong). The bundle persists while occupants change — which is what makes an organisation more durable than a coalition: the reviewer role outlives any particular reviewer, and the coordination knowledge embedded in it does not walk out of the door with the incumbent. An organisation chart, read this way, is a data structure: the compressed residue of ten thousand coordination decisions made once — who reports what to whom, who may overrule whom, where a dispute goes — so that they need not be renegotiated per task. Part III built this machinery’s dynamic counterpart; the organisation is what you get when the answers are cached.
The multi-agent community, with its usual thoroughness, catalogued the design space two decades before the current frameworks began rediscovering it. Horling and Lesser’s survey lays out the paradigms — hierarchies, holarchies, teams, congregations, societies, federations, markets, matrix organisations — each analysed for its characteristic trade-offs among efficiency, robustness, scalability, and the load placed on any single member (2004). The mapping onto today’s topologies is nearly one-to-one: the supervisor–worker pattern is a hierarchy, with the hierarchy’s known virtues (clear routing, cheap decisions) and its known pathologies (the supervisor as bottleneck and single point of failure); the router with specialist pools is a federation, brokering between sub-communities; the free-for-all group chat is a congregation, with a congregation’s amiable inefficiency; and Chapter 15‘s internal markets appear in the catalogue as precisely one paradigm among several — appropriate, as ever, under specific conditions rather than universally. An engineer choosing a multi-agent topology today is choosing from this menu, usually without the menu, and the trade-offs were measured before some of today’s frameworks’ authors were born.
Now the preface’s bluntest promise can be paid in full. Giving four agents the titles Chief Executive, Architect, Developer, and Reviewer does not, by itself, produce an organisation — and the last three paragraphs say why: a job title is a costume, and a role is a costume plus a jurisdiction. The test is operational, and it has three clauses. Does the title change what the agent sees — does the Reviewer receive different context from the Developer, or the same transcript with different pleasantries? Does it change what the agent may do — can the Reviewer actually block a merge, or merely express reservations into the void? Does it change what the agent must answer for — is the Reviewer’s approval recorded, consequential, and attributable when the deployment burns? A prompt announcing “you are a meticulous senior reviewer” adjusts tone and, the evidence suggests, sometimes usefully; a harness rule stating “nothing merges without the reviewer’s token” changes the game being played. The distinction explains an otherwise puzzling empirical pattern: role-based systems like MetaGPT work not because their titles inspire the models but because their standard operating procedures route different artefacts to different roles — structured outputs, role-specific context, enforced hand-offs — which is to say they quietly implement real information flow and authority behind the costumes (2024). The costume works when there is a body underneath.
The same lens turns the field’s best failure data into an organisational diagnosis. Chapter 10 read the MAST taxonomy — fourteen failure modes from over a thousand annotated traces of real multi-agent systems (Cemri et al., 2025) — as a catalogue of missing teamwork machinery; read it again at this chapter’s altitude and it is a catalogue of missing organisation. The specification failures are the absence of a constitution: jurisdictions undefined, so agents duplicate work or each assume the other holds it. The inter-agent misalignment failures are the absence of an escalation path: disagreement has nowhere to go, so it festers in the transcript or resolves by whoever speaks last. And the verification and termination failures are the absence of accountability and of terminating authority: nobody must answer for the assembled whole, and nobody is empowered to say done — or stop. Human organisations solved every one of these with structure rather than personality centuries ago, which is why the taxonomy reads less like a bug database than a management consultant’s report on a company that has titles but no organisation.
What organisations cannot do for themselves is guard their own rules. A structure is a set of standing arrangements, and standing arrangements invite two questions structure cannot answer: who may change them, and what happens when someone simply ignores them? The reviewer’s blocking token is real only if something makes it so — if the merge cannot happen without it, or if violating it costs more than complying. Rules, it turns out, need rules of their own: rules about who makes rules, rules about what violations cost, rules that keep their force as members, tasks, and even the organisation’s own structure turn over. Those are the institutions of this chapter’s title, and the chapter climbs to them now.
16.4 The Rules of the Game: Norms and Institutions
North, who gave institutional economics its modern shape, defined an institution in five words that have organised the field since: institutions are “the rules of the game” — the humanly devised constraints, formal and informal alike, that structure interaction and make other parties’ behaviour predictable enough to deal with (1990). His companion distinction slots the ladder’s rungs into place: institutions are the rules; organisations are the players — teams formed to win under those rules. And with the genus named, the reader can look back across Part IV and recognise a family portrait. Chapter 13’s voting rules, Chapter 14’s rules of encounter, Chapter 15’s auction formats: every one an institution, studied one at a time. This section asks what the multi-agent tradition made of the genus itself — rules as engineered, first-class objects — and it must begin by paying a debt to Chapter 11, because this book has met rules for agents once before.
Chapter 11’s conventions and social laws covered the easy case, though it did not feel easy at the time: coordination among the willing. A convention — drive on the left, yield to the agent already holding the lock — is self-enforcing once established, because no agent gains by deviating unilaterally; the rule needs announcing, not policing. The hard case is the one this part of the book has been circling for five chapters: rules whose violation pays. The coder gains by skipping the flaky test suite; the subagent gains by overstating its confidence; the bidder gains by shilling. No convention holds there, because the deviator profits precisely when everyone else complies. Regularity among the unwilling needs a stronger instrument, and the instrument is the norm, with its distinctive deontic vocabulary: obligation (must), permission (may), and prohibition (must not) — words that do not describe what agents do, but prescribe what they answer for.
The conceptual heart of the matter — the thing that makes normative systems a subject rather than a synonym for constraints — is that a norm, unlike a law of physics, can be broken. A violation is not a malfunction of the system; it is a state the system must be able to represent, detect, and respond to. That sounds like a concession to imperfection and is actually a design doctrine: a specification that says “agents cannot do X” when it means “agents ought not do X” has simply declined to say what happens when they do — and something will happen, in production, on a Friday. The normative stance obliges the designer to complete the sentence: prohibited and, upon violation, this — a sanction, a repair, an escalation, an entry in a ledger. Half the failure taxonomy of the previous section is, at bottom, systems that specified the ought and omitted the or-else.
Why prefer breakable rules at all, when a harness could often make the violation impossible? Because breakability is what preserves the autonomy the agents were hired for. The normative multi-agent systems programme — a research community substantial enough to have produced its own handbook (Andrighetto et al., 2013) — studied agents that represent norms explicitly and reason about compliance as a decision: weigh the obligation against the goals, and sometimes, deliberately, violate. The standard intuition pump is the ambulance at the red light: a driver incapable of running the light is not safe but merely rigid, and the whole point of employing a judging agent rather than a script is that some situations warrant the violation. An agent that can never break a minor norm to prevent a major harm has not been aligned; it has been laminated. Norms, in other words, are the technology for giving autonomous agents guidance with exceptions — predictability without lobotomy.
The multi-agent tradition did not stop at theory; it built the rules as running code. The electronic institution programme — which grew, fittingly for this part of the book, out of digitising a Spanish fish auction — specified institutions as formal, executable artefacts: roles an agent may adopt, scenes governing what may be said when, transition rules between scenes, and governors that mediate every agent’s actions against the specification (Esteva et al., 2001). An electronic institution is an institution you can compile, and the move is this book’s recurring one performed at the largest scale yet: as protocols disciplined messages (Chapter 8) and mechanisms disciplined bids (Chapter 15), institutions discipline whole societies of interactions — and machine-readable rules can be verified, versioned, and diffed, which is more than can be said for most constitutions.
One further idea, from philosophy rather than economics, completes the picture, because rules do more than constrain the game — some rules bring its pieces into existence. Searle distinguished regulative rules, which govern an activity that exists anyway (drive on the left), from constitutive rules, of the form “X counts as Y in context C”, which create the very possibility of the activity: a crossed line counts as a goal, a signed slip counts as a payment (1995). Institutional facts exist because rules say certain acts count as them — and an agent harness is dense with such facts. The reviewer’s token counts as approval; the passing suite counts as verification; the orchestrator’s message counts as a task award. Chapter 8’s declarations — speech acts that make things so by saying so — were constitutive rules seen one utterance at a time, and the reason a job title without a jurisdiction is empty (Section 16.3) can now be said precisely: nothing in the system counts as anything because of it.
Every norm in the harness now faces a fork this chapter has been approaching since Section 15.5, and the fork deserves its terminology. The designer can regiment: make the violation impossible — the merge without the reviewer’s token is not forbidden but unrepresentable, a permission the API simply does not expose. Or the designer can enforce: allow the violation, detect it, and make it cost — audit, sanction, restitution. Regimentation is certain, and certainty is its weakness: it needs every legitimate exception anticipated in advance (there is no ambulance clause in a wall), it converts judgement into architecture, and it fails closed — blocking the emergency fix at three in the morning with the same serenity it blocks the sloppy one. Enforcement preserves the exception and the autonomy, and its price is the full normative apparatus: monitoring, attribution (Chapter 9’s provenance, now load-bearing), and a sanction that actually bites. The decision rule falls out of Chapter 6: where violation is catastrophic or irreversible, build the wall; where it is recoverable and judgement-laden, post the fine — and notice that the harness, unlike human society, gets to choose per rule, cheaply, which is a liberty no legislature ever had.
That preference for enforcement over regimentation has an empirical charter older than any agent harness, and paying it discharges a debt left open in Chapter 12. There the tragedy of the commons was diagnosed and its cure deferred — a shared resource, the token budget or the rate limit, grazed bare by locally sensible appetites, with the remedy filed under institutions the book had not yet reached. Ostrom’s fieldwork is the remedy, and it is more cheering than Hardin’s theorem feared: studying commons that had endured for centuries — Swiss alpine pastures, Spanish irrigation networks, Japanese village forests — she found communities governing shared resources sustainably without either privatising them or handing them to a central authority, and distilled the arrangements that worked into a handful of design principles (Ostrom, 1990). Several will be familiar, because this book has been building them under other names (Table 16.2): boundaries clear enough to say who may draw on the resource, monitoring by the users themselves rather than a distant overseer, graduated sanctions that meet a first lapse gently and a persistent one firmly, and nested tiers of governance for resources too large for one body. The graduated sanction is Section 12.4’s forgiveness in institutional dress; the monitoring is the observability Chapter 23 will insist on; the nesting is Chapter 21’s hierarchy of orchestrators — and the whole is the token commons of Section 12.1 given at last the institution it was always going to need. The commons is not doomed. It is merely ungoverned, and Ostrom catalogued the governments that hold.
| Ostrom’s design principle | Where this book builds it |
|---|---|
| Clearly defined boundaries | Budgets subdivided per agent to enclose the token commons (Section 12.1, Chapter 23) |
| Rules congruent with local conditions | Mechanisms and allocations fitted to the task, not imposed uniform (Chapter 15) |
| Collective-choice arrangements | Voting and social choice over the rules themselves (Chapter 13) |
| Monitoring | Observability and futility detection (Chapter 23); provenance (Chapter 9) |
| Graduated sanctions | Section 12.4’s forgiveness; the fine chosen over the wall |
| Conflict-resolution mechanisms | Negotiation and argumentation (Chapter 14); the human gate (Chapter 23) |
| Recognition of the right to self-organise | Norms with exceptions — enforcement chosen over regimentation |
| Nested enterprises | Hierarchies of orchestrators, coordinators of coordinators (Chapter 11, Chapter 21) |
Sanctions, though, expose the one dependency this section cannot discharge on its own. A fine requires someone to fine: a persistent, identifiable someone whose past conduct can be attached to its present name and carried into its future dealings. Regimentation works on strangers; enforcement works on known parties — and the moment the system’s answer to “who did this?” is “a fresh API key, no priors”, the whole normative apparatus swings in the air. What converts conduct into consequence, across time and between strangers, is reputation, and reputation runs on the scarcity of names. That institution — the last of the chapter, and the close of Part IV — is next.
16.5 Trust, Reputation, and the Price of a Name
Strip the sentiment away and trust is a decision: to make oneself vulnerable to another party’s conduct, on an expectation about that conduct which cannot be verified in advance. Every delegation in this book has been such a decision — the orchestrator awarding a task on a bid it cannot check, the reviewer accepting a test report it did not run — and the practical question is always the same: where is the expectation supposed to come from? Chapter 12 supplied one answer with a theorem attached: repeated play. Under the folk theorem’s shadow of the future (Section 12.4), good conduct is rational because we meet again, and Axelrod’s tournaments showed the logic breeding cooperation among egoists (1984). But the answer has a scaling problem built in: it protects ongoing pairs. In any open system — a marketplace, a protocol, an agent platform — most encounters are first encounters between parties who will never meet twice. The folk theorem holds between old acquaintances; commerce, mostly, happens between strangers.
Reputation is the institution that closes the gap, and its trick can be said in one line: it makes the shadow of the future portable — my experience of you becomes everyone’s expectation of you. A reputation system collects reports of past conduct, aggregates them, and publishes the aggregate where future counterparties will look (Resnick et al., 2000), and the effect is to change the game’s structure without touching the players: your next counterparty may be a stranger, but the ledger is not, so defecting against one partner is now defecting against all future partners at once. The demonstration at civilisation scale is the online marketplace, where millions of strangers ship goods to one another on the strength of small gold stars — a repeated game against the community, assembled out of one-shot games against individuals, by bookkeeping alone.
The multi-agent community, which needed exactly this institution for its open-systems ambitions, formalised it early — the first computational treatment of trust was a 1994 doctoral thesis (Marsh, 1994), and the decade of models that followed is mapped in two standard surveys (Ramchurn et al., 2004; Sabater & Sierra, 2005). The recurring ingredients: direct experience (what you did to me), witness reports (what others say you did to them), certified references (what an authority vouches), and role-based priors (what your position implies before you have done anything). And the recurring design questions have shapes the reader has met: aggregating witness reports is Chapter 13’s problem wearing a trench coat — whom to count, how to weight, and what to do about colluding witnesses; evidence must be discounted as it ages, since conduct drifts; and trust is a vector, not a scalar — an agent trusted to write code is not thereby trusted to review its own, a distinction this book’s running team has been quietly enforcing since Chapter 10.
All of it, though — every star, every witness, every sanction of the previous section — rests on an assumption so natural it goes unstated: that one participant is one identity. Douceur, examining peer-to-peer systems, proved the assumption unfounded in general: without a trusted authority that certifies identities, a single adversary can always present arbitrarily many, and no purely local scheme of challenges among peers can reliably tell one mind wearing many masks from many minds (2002). He named it the Sybil attack, after a celebrated case study of multiple personality, and its reach is the whole of this part of the book: votes can be stuffed, auctions shilled, reputations farmed — every mechanism whose guarantee is stated per participant is an open door, because the stars can be manufactured by a crowd of one.
Even short of outright attack, cheap identity corrodes the institution economically. Friedman and Resnick analysed what happens when names are free: the past becomes optional — misbehave, discard the sullied name, re-register clean, a manoeuvre the literature calls whitewashing — and the rational community response is grim: treat every newcomer as a potential reborn villain, and make them earn their way up from the bottom (2001). That is the social cost of cheap pseudonyms: honest newcomers pay, permanently, a distrust tax levied by the mere possibility of the whitewasher. The remedy is the one this chapter has been converging on from two directions: names must cost something — an entry fee, a posted bond, a certified link to a costly external identity, a history that cannot be shed — and with that, Section 15.5’s passing remark and Section 16.4’s dangling dependency land in the same place. Beneath every institution in this chapter sits a registry, and the registry is an institution too — the ground floor of the stack, on which markets, norms, and reputations all stand.
Agent platforms are the cheap-pseudonym problem at its theoretical limit — an identity is an API key, spawning is a loop, whitewashing is a for statement — so the engineer must decide, deliberately, what a reputation attaches to. Upward, to the operator: the human or organisation behind the key, the accountable principal — which is where Chapter 26 will pick up the thread. Inward, to the model: track records per underlying model are genuinely informative, with the Chapter 13 caveat now running in reverse — copies share weights, so one copy’s demonstrated flaw is evidence about all of them, which makes model-level reputation efficient exactly where it makes it unfair to the well-contexted individual copy. Or to the name itself, made costly: bonded identities with stakes to forfeit, which is what Section 16.4’s fines need in order to bite. And agent reputation can be built of sterner stuff than gold stars: calibration histories (Section 15.2’s curse correction), signed attestations of runs actually executed, verifiable logs with provenance (Chapter 9) — reputation as evidence, not gossip, one more affordance human institutions never had.
And with the registry in place the ladder is complete, which means Part IV is. Look back at what has been assembled since two prisoners sat in separate cells: a calculus of strategic interaction (Chapter 12), and then its four great expenditures, exactly as promised — ballots for aggregating what strangers think (Chapter 13), bargains and arguments for reconciling what they want and believe (Chapter 14), prices for allocating what they cannot all have (Chapter 15), and now coalitions, organisations, and institutions for the strangers who stop being strangers (Chapter 16). The instruments stack: markets presuppose identity, sanctions presuppose registries, organisations presuppose rules — institutions all the way down.
One assumption, though, has run beneath all five chapters, unexamined because Part IV needed it: the players are fixed. Their preferences, capabilities, and dispositions were given once and stayed put while we designed around them. Real agents — the trained, fine-tuned, feedback-driven kind this book is actually about — do not stay put. They adapt, and they adapt to the rules, which turns every institution in this part into a curriculum and inverts the design question one final time: not “what will these players do under these rules?” but “what will these rules teach the players to become?” That is learning in multi-agent systems, it is where the mathematics gets strange and the engineering gets urgent, and it is Part V.
16.6 Summary
- Coalitional game theory asks two questions: who joins whom, and who gets what. The characteristic function prices every possible alliance; superadditivity makes merging tempting but not automatic; and finding the best partition of agents into working groups is computationally hard in a way orchestrator designers inherit whether they know it or not.
- The core is stability, and it can be empty. A division of the spoils is in the core when no subgroup could do better by walking out — and some perfectly reasonable games have no such division at all, so endless renegotiation is sometimes a property of the situation, not a failure of the negotiators.
- The Shapley value is fairness, axiomatised. Pay each member its marginal contribution, averaged over every order in which the coalition might have assembled: the unique division satisfying a short list of mild axioms — the axiomatic method once more picking a single answer out of a crowded field, as it did for Arrow and for Nash.
- Shapley’s second career is credit assignment. The same arithmetic that divides a coalition’s spoils attributes a model’s prediction to its features and a team’s performance to its members; it is exact, principled, and exponentially expensive, which is why the practical art is sampling it — and why “which agent earned its tokens” is answerable at all.
- Organisations are patches for bounded minds and costly transactions. Coase explains why the boundary exists; Simon explains why there is structure inside it. A role is real when it changes information flow, authority, and accountability; a job title changes none of them, and a great deal of multi-agent folklore consists of job titles and hope.
- Institutions are the rules that outlast the players. Norms bind where Chapter 11’s conventions merely coordinate — obligation, violation, sanction — and an agent harness holds an option human institutions envy: regimentation, making the violation impossible instead of expensive. Choosing between the wall and the fine is a design decision with a price on each side.
- Reputation is the folk theorem made portable, and it runs on identity. Trust systems carry the shadow of the future between strangers who will never meet again — and they are only as strong as the scarcity of names, which sybils and cheap pseudonyms counterfeit. Identity is not a given in agent systems; it is an institution someone must build.
- Part IV ends where it began, with the rules deciding the game. Ballots, bargains, prices, and organisations are one toolkit: game theory spent four ways, exactly as Chapter 12 promised. Everything so far has assumed the players themselves stay fixed. Part V withdraws that assumption — the agents start learning — and the question becomes which rules survive players who adapt to them.
16.7 Exercises
Exercise 1. The orchestrator prices a worker pool exactly as Section 16.1 prescribes — by running every subset on the sprint’s task suite. The pool holds two coders c and d and a tester t, and the logged suite scores are v(\{c\}) = v(\{d\}) = 42, v(\{t\}) = 0, v(\{c, d\}) = 68, v(\{c, t\}) = v(\{d, t\}) = 61, and v(\{c, d, t\}) = 84, with v(\emptyset) = 0. (a) Test superadditivity on every disjoint pair of non-empty coalitions: list each violation, say in a sentence what the violations have in common, and name the law of Section 16.1 they measure. (b) Enumerate all five ways of partitioning the pool into working groups, total the value of each, and identify the optimal coalition structure; two features of the winner deserve a sentence apiece — what became of the grand coalition, and where the agent that is worthless alone ended up. (c) The chapter asserts that twenty agents admit “some fifty trillion” partitions; verify it. Taking B_0 = 1 and B_{n+1} = \sum_{k=0}^{n} \binom{n}{k} B_k for the number of partitions of an n-element set, compute B_{20} exactly; compare it with the 2^{20} ablation runs that would price every coalition of twenty agents; and state which of the theory’s two questions — what a group is worth, or how best to group — is the computationally hard one here, and by what factor at n = 20.
Exercise 2. Section 16.2 leaves the 300-token majority game cycling forever (Figure 16.2); this exercise prices the repair the chapter prescribes — change the values, change the game. The orchestrator adds a completion bonus of B tokens paid only if all three agents finish together, so that v(N) = 300 + B, while any pair can still seize 300 and a lone agent still earns nothing. (a) Show that the core is non-empty exactly when B \ge 150: derive the necessity from the three pair inequalities, and establish sufficiency by exhibiting an allocation that satisfies them all. (b) Show that at B = 150 the core is a single point, and name it. (c) At B = 210, describe the core completely as a system of bounds on the three shares, show that the reviewer’s stable share ranges exactly from 90 to 210 — stability constrains without choosing — and compute the Shapley value of the subsidised game from two axioms, without touching the closed form; check that it sits inside every bound with room to spare. (d) Watch the theory happen: implement the myopic renegotiation loop in which, starting from the equal split of v(N), the first agent holding a profitable deviation lures the poorest other agent still being paid (ties broken in the fixed order coder, tester, reviewer) with that agent’s current share plus 10 tokens, keeps the remainder of the 300, and deviates only if the remainder strictly beats its own current payoff; run it with cycle detection at B \in \{0, 120, 150, 210\} and report what happens in each case — then say in one sentence why no prompt engineering applied to the three negotiators could change the B = 0 outcome. (The game itself ships as majority_game in the companion repository’s foundations/algorithms/shapley.py, though the loop needs nothing but the story.)
Exercise 3. A sprint’s ablation table decomposes cleanly: the coder alone ships 40 suite points; the tester adds 18, but only alongside the coder; the reviewer adds 12, again only alongside the coder; and a final 14 points of integration polish appear only when all three work together. (a) Write the characteristic function as the weighted sum v = 40\,u_{\{c\}} + 18\,u_{\{c,t\}} + 12\,u_{\{c,r\}} + 14\,u_{\{c,t,r\}} of unanimity games, where u_T(S) = 1 if T \subseteq S and 0 otherwise, and tabulate all eight values of v. (b) Derive the Shapley value of a unanimity game u_T from three of the four axioms — players outside T add nothing to any coalition, players inside T are interchangeable, and the shares must exhaust u_T(N) = 1 — without evaluating the closed form. (c) Now let the fourth axiom, additivity, do the work the formula would have done: read off the team’s exact shares as fractions and confirm they exhaust 84. (d) Check your fractions against the chapter’s shapley function, which ships verbatim in foundations/algorithms/shapley.py. (e) Test whether this fair division is also stable — verify every secession inequality — and reconcile the answer with Exercise 2 in a sentence: what do the two games say about when fairness and stability coincide?
Exercise 4. Table 16.1 asserts that the intuitive audit fails in both directions; make both failures numeric. Game R — the redundant pair: the coder is worth 40 on its own and test coverage is worth a further 30 whenever at least one of two testers t_1, t_2 is present, so v(S) = 40 \cdot [c \in S] + 30 \cdot [S \cap \{t_1, t_2\} \neq \emptyset], square brackets worth 1 when their condition holds and 0 otherwise. Game C — the complementary pair: nothing ships unless the coder and the reviewer are both present (jointly worth 80), and the tester adds 10 alongside both, so v = 80\,u_{\{c,r\}} + 10\,u_{\{c,r,t\}} in Exercise 3’s notation. (a) For each game compute the leave-one-out audit \mathrm{LOO}_i = v(N) - v(N \setminus \{i\}) by hand; show that Game R’s audit sums to 40 against a team worth 70, identifying precisely what the missing 30 is, while Game C’s sums to 190 against a team worth 90. (b) Compute the Shapley values of both games by hand — Exercise 3’s decomposition makes Game C a one-liner — and confirm each exhausts v(N). (c) Implement loo alongside the repository’s foundations/algorithms/shapley.py and tabulate audit beside fair share for both games. (d) Exactness costs an exponential; implement the remedy the chapter names: estimate \phi on Game C by averaging marginal contributions over m sampled arrival orders, measure the mean absolute error of the coder’s estimated share at m = 100 and m = 10{,}000 over twenty independent runs, confirm the shrink is consistent with the 1/\sqrt{m} rate, and say why this estimator — not the exact sum — is what runs inside every production SHAP implementation.
Exercise 5. Simon’s claim that organisations are prosthetics for bounded minds becomes, for language-model agents, an exercise in arithmetic, because the bound has a number. Take a team in which every worker posts 8 status updates of 300 tokens per sprint, a supervisor’s digest costs 500 tokens, and no member can attend to more than W = 200{,}000 tokens of inbound traffic per sprint; count only what a member must read. (a) In the flat congregation — every update visible to every member — compute the per-member load at n = 100 workers, and find the largest team the window admits. (b) In the single-supervisor hierarchy, each worker reads one digest and the supervisor reads everything: compute both loads at n = 100, find the largest pool one supervisor can attend to, and state what the hierarchy did to the overload — the pathology Section 16.3 names. (c) Add a middle tier of k coordinators, each digesting for n/k workers and reading one digest from the top: show that k = 2 makes n = 100 feasible, derive the general branching bound b, compute the worker capacity of hierarchies two and three tiers deep, and conclude with the growth law that says why attention scales with depth. (d) The digest is not free: name its price in the chapter’s terms, then specify the middle coordinator’s position as the three-clause role bundle of Section 16.3 — what it reads and forwards, what it must be empowered to settle without escalating (and what becomes of the saving if it may settle nothing), and what it answers for when its digest omits the fact that mattered.
Exercise 6. The team’s norm reads “nothing merges without the reviewer’s token”, and one release cycle supplies the economics: 40 merge attempts; 3 would-be shortcut merges, each saving its coder 800 tokens of review latency and each causing 5,000 tokens of expected downstream damage if it lands; 1 genuine emergency in which waiting for review costs 12,000 tokens of outage while the merge itself is sound; an audit agent that reads merge logs at 150 tokens per merge and detects an unreviewed merge with probability p_d = 0.5; and fines that are transfers into the team’s shared pool, not burnt tokens. (a) A rational agent violates when its private gain exceeds the expected fine p_d f: find the window of fines that deters every shortcut yet lets the ambulance through, and verify that f = 2{,}000 sorts all four candidate violations correctly. (b) Price the two regimes over the cycle — the wall (regimentation: the unreviewed merge is unrepresentable) against the fine at f = 2{,}000 with every merge audited — name the winner, and in doing so say what a fine that is a transfer costs the system, and where enforcement’s real deadweight sits. (c) Find both break-evens: the audit price per merge at which the wall draws level, and the emergency frequency per cycle below which the wall wins; state the resulting decision rule and check it against the chapter’s — where violation is catastrophic or irreversible, build the wall. (d) Ostrom’s graduated sanctions (Table 16.2), priced: against the flat fine of 2,000, evaluate the schedule 500, then 2,000, then 8,000 for the first, second, and third detected offences — the expected penalty at each rung, the rung at which the persistent violator is deterred, and what an honest one-off lapse pays under each regime; then let detection collapse to p_d = 0.25 with fines capped at 2,500 by the offender’s remaining budget, show the deterrent window is now empty, and conclude in the chapter’s terms what enforcement actually runs on.
Exercise 7. Every number in this exercise is a consequence of what a name costs. (a) Sybils. The platform computes standing by strict majority of good over bad reports from distinct identities; a shirking contractor has earned 6 truthful bad reports, and 3 honest counterparties report good. How many fresh keys must the contractor mint, each filing “good”, to flip its own standing — and what does the attack cost when keys are free? If registering a key costs F tokens, what F makes the forgery unprofitable against a contract worth 2,000 tokens? State the theorem-shaped reason from Section 16.5 why no purely local test can prevent the minting itself. (b) Whitewashing. An honest name earns 100 tokens per round indefinitely; a cheat skims an extra 150 in one round, after which the name is burnt — detected at the round’s end and never hired again. With free names and trusting defaults, compute the whitewasher’s per-round earnings and show that cheating dominates honesty; then find the smallest entry fee per name that restores honesty, and name the quantity it equals. (c) Probation. Suppose the platform instead trusts no newcomer: for its first k rounds a fresh name receives only low-stakes work paying 50 per round with nothing worth stealing, and full trust thereafter. Compute the whitewasher’s per-round rate as a function of k, find the smallest deterrent k, and price the distrust tax this levies on every honest newcomer — comparing it with (b)’s entry fee and saying carefully who pays under each design. (d) Generalise (c): with cheat premium g and probation wage w < 100, show the deterrent probation is k_{\min} = \lceil g / (100 - w) \rceil and that the minimum tax on an honest newcomer is at least g, exactly g when 100 - w divides g (as here) — the invariant that someone must forfeit no less than the cheat premium once per name — then place fee and probation among the chapter’s ways of making a name cost something, and say which the chapter’s evidence-based reputations (signed attestations, verifiable logs) would substitute for both.
Exercise 8. Foundry is a four-agent harness assembled by the book’s least favourite method: the system prompts announce a “Chief Executive Officer”, a “Chief Technology Officer” (“ultimately responsible for architecture”), a “Senior Staff Engineer”, and a “Head of Quality”; every agent receives the identical full transcript every turn; every agent holds the identical toolset, including git.push to the default branch; the run terminates when any message contains “ship it”, whoever says it; and no record survives of who approved what. (a) Dismantle it with Section 16.3’s three-clause test: for each title, say what its holder sees, may do, and must answer for, and conclude what the four titles are in the chapter’s vocabulary. (b) Redesign it minimally: for each of the four roles specify the three clauses concretely — the context filter (what it reads), the authority (the one or two tool permissions or decisions it alone holds), and the accountability (the ledger entry that attributes its consequential acts); then write the redesign’s three load-bearing constitutive rules in Searle’s “X counts as Y in context C” form, each machine-checkable in the manner of Section 16.4’s electronic institutions. (c) Map the three MAST failure families the chapter re-reads as missing organisation — specification, inter-agent misalignment, verification-and-termination — each to the clause whose absence invites it in Foundry as shipped, and to the redesign element that forecloses it. (d) Choose exactly one rule of your redesign to regiment and one to enforce, justifying each by the chapter’s decision rule — and note, for the regimented one, what the wall costs on the night the emergency arrives.
Exercise 9 (lab). Section 16.1‘s boldest claim is that for agent teams the characteristic function is an empirical object; measure one. Fix a pipeline of three live-model stages — coder, tester, reviewer, in that order, later stages reading earlier stages’ output — over a suite of ten small, independent programming tasks with hidden unit tests, one fixed prompt per role, one fixed per-run token budget. For each of the seven non-empty subsets S of the three roles, run the pipeline with only S’s stages present (missing stages are simply skipped) and record v(S) as the number of tasks whose hidden tests pass, averaging at least two repetitions per subset; set v(\emptyset) = 0. Then (a) test superadditivity on every disjoint pair of non-empty coalitions and report any violations, with a sentence on what they say about this team’s shape; (b) compute the exact Shapley division of v(N) with the repository’s foundations/algorithms/shapley.py; (c) compute the leave-one-out audit from the same table and report whether it ranks the three roles in the same order; (d) test whether the equal three-way split of v(N) lies in the core using in_core, and if it does not, name a seceding coalition. Record the model identifier and the date beside the table: the scores will not survive the year, and the durable finding is the method — and whether the reviewer’s marginal value survives being measured rather than assumed.
Exercise 10 (lab). The organisational paradigms of Section 16.3 make different promises; buy one of each and audit them. Same four live-model agents, same twelve small independent repository tasks, same total token budget per condition, three wirings: a hierarchy (an orchestrator decomposes, assigns, integrates, and alone declares termination); a congregation (one shared channel, no assigned authority, any agent may claim any task); and a market (each task auctioned to the workers by announce–bid–award, with the repository’s foundations/algorithms/contract_net.py supplying the protocol). Journal every run in the manner of frontier/rig.py, and count per condition four MAST-style failure events, each defined as something legible in the journal — detectors in the manner of frontier/patterns/signatures.py, the census discipline of frontier/scaling_lab/sweep.py: duplicated work (two agents complete the same task), orphaned task (no agent ever claims it), contradictory artefact (two agents’ outputs conflict at integration), and non-termination (the run ends by budget exhaustion rather than by a declared finish). Tabulate the four failure counts beside quality, tokens, and latency for each wiring; then write the finding as Horling and Lesser would — one sentence per topology naming the failure family it invites and the one it forecloses — and check it against the paradigm trade-offs the chapter maps onto modern topologies. Record the model identifier and the date: the counts are perishable; the assignment of failure family to topology is the durable pattern, and the chapter’s claim that these trade-offs were measured decades before today’s frameworks is what your table either confirms or complicates.