A Game Where Agreeing Costs Something

A spec for a multi-agent environment where positions hold a conflict instead of converging on it. It's written for anyone whose agents agree fast and build nothing after that. You get the state model, the move set, the one banned move, and a plain account of what isn't machine-checkable yet.

Checked against one run: Eight Positions, and the Controls That Reached the Same Answer.

Most multi-agent setups end in a summary. The agents converge because nothing makes converging expensive. Agreement is the highest-probability continuation for a language model, so it arrives early, and what gets built after that is decoration.

Here's an environment where a concession is an event with a stated cause, and a round that changed nothing is recorded as having changed nothing.

#State

State isn't the transcript. It's a triple.

S = ⟨ M, G, K ⟩

M  slot map:  which functional slots in the activity system are staffed,
              which are empty, which aren't named as slots yet
G  gap map:   which gaps are open, what backs each one, who holds it
K  claim:     which slot is claimed, with what object in hand, in what role

M separates work that exists from work that's needed and isn't being done. An empty slot still plays. Whoever claims it speaks for it.

G separates a gap from a complaint. A gap has evidence and a holder. A gap nobody holds is the interesting case: the system keeps producing the failure and no one is accountable.

K separates a claim from a request. A request asks to be let in. A claim names a slot, an object and a role, and all three can be shown wrong.

The result of a run is a configuration of K, not a document. Documents fall out of it.

#Participants

Position. Goals · Values · Knowledge · Resources · Constraints · Language · Decision Rules · Blind Spots · Authority · Dependencies. What the agent knows and controls.

Motivation. Core Fear · Core Desire · Defense Move · Under Pressure · Concession Rule. What the agent loses if it yields.

The second layer isn't decoration. An agent with nothing to lose folds on the first strong argument, three positions reach consensus in two rounds, and you get a protocol of polite agreement that builds nothing. The motivation layer makes a conflict holdable, and that's the difference between a game and a chat.

Motivation patterns attach to functional slots, never to real people, and each run reassigns them. What survives across patterns came from the shape of the gap. What doesn't came from the cast.

Each position is its own agent with its own context and persists across rounds, so a concession is an event in its own history. It sees the material, its own spec, the shared record, and the current request. Never other specs, the service loop, the output format, or the success criteria.

#Legal moves

• Open a gap.
• Contest another position's gap as fake.
• Take over holding a gap.
• Refuse a claim, with grounds.

#The illegal move

Conceding without moving your own Decision Rule.

This is the whole design. In free-form multi-agent dialogue the dominant failure isn't hallucination, it's premature agreement. It's cheap to produce, it reads as cooperation, and any reward computed off the transcript pays for it. A collapsed run and a real one look alike. Both are polite. Both end with a plan.

So a position can't agree without naming the rule it yielded under. If it yields, it quotes its Concession Rule, names which condition fired, and shows what satisfied it. A concession without that citation voids the round, logged as an engine failure rather than a result of the game.

Two things follow. Yielding becomes a typed event instead of a tone. And the gap between "I see your point" and "my rule fired" becomes visible from outside the agent, which is the only version of it anyone can audit.

#Transition function

After a move, at least one of three must change:

1. a new gap is opened,
2. a gap's holder is reassigned,
3. the claim configuration changes.

A round that changed none of the three is an idle round and gets recorded as one. The count is kept by an agent that doesn't run the rounds. Otherwise the process grades its own output.

#Termination

• The configuration holds for two rounds under active pressure. The claim stabilized.
• Three idle rounds in a row. That's a refusal, recorded as a refusal, not as a run to retry. A refusal is a finding about the material.
• Budget exhausted.

#Non-playing roles

• Facilitator. Runs the round, applies operators, decides what enters the shared record. No opinion on the substance. Its only goal is that the conflict holds rather than resolves early.
• Methodologist. Watches the thinking, not the subject. Catches question substitution, agreement without rule movement, fights about words. Can halt a round.
• Observer. Records what actually changed in S. Keeps the idle-round count.
• Historian. Tracks how each position moved: where it started, where it shifted, on what grounds. Without this you can't show the final construction is new rather than something said in round one.

These four can't collapse into one orchestrator. That collapse is what standard multi-agent harnesses do, and it's why they give you a summary. The orchestrator that decides what gets said also decides what counts as change and writes the history. No outside view is left. Same reason the session holding the hypothesis must not run the rounds: if it picks the operators, the hypothesis enters through those choices and comes back out looking like a result.

#Operators

#Two questions, answered up front

1. How is a Decision Rule represented so its movement is machine-checkable?

A rule is a predicate over state with explicit firing conditions, frozen before round one:

rule_id:              R3
holder:               <position>
predicate:            IF <condition over S> THEN <permitted action>
concession_condition: <the one condition under which this position yields>
cost:                 <what the position gives up when it fires>

A concession counts only if the agent quotes the rule verbatim by id, names the condition that fired, and points at the item in the shared record that satisfies it. The check compares the quoted condition against that item.

Mechanical today: rule text is frozen at setup, so verbatim quoting is a string match. Presence of id, condition and pointer is a schema check. Idle-round accounting is arithmetic. Not mechanical: whether the cited item actually satisfies the condition. That's a semantic judgment and the methodologist agent makes it. So the format doesn't automate the check. It puts the judgment in one place and leaves a record a second reader can audit afterwards. Full automation needs conditions written against a typed state object, and this version has none.

2. What stops a participant from declaring a trivial rule that any concession satisfies?

Three defenses. The rule is fixed before round one and written to the run file, never rewritten, and a rule that changes mid-run is an engine failure. A rule that fires on any input is thrown out at setup: the methodologist tests it against three unrelated candidate rounds, and firing on all three disqualifies it. And the rule has to name what the position loses when it fires. A concession rule with no cost isn't one.

The residual hole, stated plainly. The setup agent writes both the position and its rule, so it can produce a rule that's tight in form and loose in fact. The three-round test catches the blatant version, not the subtle one. A rule can also discriminate honestly and still be worded so its condition is nearly certain to arise. Detection is after the fact: if a position concedes in every run regardless of motivation pattern, its rule was cheap. That's a diagnostic across runs, not a guard inside one.

#What this does not cover

A designed session is a laboratory. Roles handed out, positions and rules written before round one, service loop in place. Undesigned material, an ordinary thread where nobody was assigned a position, hasn't been tested. Whether this survives when the environment isn't built for it is open.

One material so far, and the output format is partly reverse-engineered from that same run. It's fitted to it to an unknown degree and needs re-checking on fresh material before anyone calls it general.

The Concession Rule gives a form that can be checked. Full automatic checking isn't implemented. The semantic step is a model judgment, and the guarantee is that the judgment is recorded, not that it's right.

#Provenance

The apparatus comes from Shchedrovitsky's organizational-activity games: positions drawn from a system of activity rather than an attendee list, a service loop that doesn't play, operators for a facilitator, rounds that run to reconstruction. Added in the port to agents: the motivation layer with an explicit Concession Rule, per-position context isolation, idle-round accounting as state, and the ban on collapsing the service roles into one orchestrator. 2026-07-28.