Why multiplayer games resist solution, and what the self-balancing dynamics tell us about tractable approximations.
Links: The Lemonade Stand Experiment (two competing agents emailing each other to engineer a shared legal workaround), Gaming, Monopoly, Slay, Slay-C, Computation and Information Theory, Economics, Risk and Entrepreneurship, Cyborg Model, Civilizational Cycles, Opposing Forces, Randomness as Termination (N≥3) (the design-side corollary: this gang-up equilibrium never terminates without a randomization layer), Risk — The Attrition Constant (this problem with the arithmetic filled in — Risk’s combat has no tactical deterrent (matched stacks of 12+ favour the attacker, and the required defensive premium shrinks as borders grow), yet a won battle costs 85% of the attacking force, so in a symmetric three-player standoff the winner falls from a third of the board’s force to 13.6% while the bystander rises to 86.4%. A worked case of relative-position-is-everything, and of stability recovered from player count rather than from mechanics)
Two-player zero-sum games have clean solutions. Von Neumann’s minimax theorem guarantees an optimal strategy exists, and alpha-beta search can approximate it efficiently. Chess, Go, two-player Slay — these are hard in practice (the game trees are enormous) but tractable in principle. Stockfish and AlphaGo prove that strong approximations are achievable.
The moment you add a third player, the structure breaks. Minimax no longer applies. The solution concept shifts to Nash equilibrium, and computing Nash equilibria in general-sum multiplayer games is PPAD-complete — believed to be computationally intractable, though not NP-hard in the classical sense. More importantly, Nash equilibria in multiplayer games are often non-unique, meaning there isn’t a single “optimal” strategy — there are many equilibria, and which one emerges depends on coordination and convention, not just computation.
This isn’t a limitation of current algorithms. It’s structural. The coalition problem is the reason, and it appears in every multiplayer game Chris has worked on.
Slay is essentially Risk with cleaner mechanics — hex territory control, income based on territory size, unit maintenance costs. The two-player version is tractable: alpha-beta search with heuristic evaluation produces competitive play. But six-player Slay reintroduces the full coalition problem:
The two-player simplification in the current Slay project was a deliberate choice to make the AI tractable. Restoring six players is an open problem.
The tractable 1v1 base case — the evaluation model and search design, plus three theses that generalize (the cut/join graph duality, realizable-treasury / use-it-or-lose-it, and eval-beats-depth in wide-branching games) — is worked out in Slay — Evaluation & Search.
Risk adds explicit growth mechanics that change the coalition dynamics:
The combat math is solved. Given N attackers and M defenders, the probability distribution of outcomes is computable. This is just dice math — a solved problem.
The multiplayer dynamics are not solved. Who to attack, when to attack, when to hold, when to break an alliance — this is the coalition problem in its purest form.
The three-player stable state. In a three-player Risk game (or when a larger game reduces to three players), a natural self-balancing dynamic emerges: the two weaker players gang up on the leader. When the leader is sufficiently weakened and one of the former underdogs takes the lead, alliances swap. This cycle repeats, creating a stable oscillation around rough equilibrium.
This is an emergent phenomenon — nobody designs it, it arises from rational self-interest. Each weaker player independently arrives at the same conclusion: the leader is the biggest threat to my survival, so I should pressure the leader. No coordination required.
Connection to civilizational cycles. This is precisely the asabiyyah dynamic from Civilizational Cycles and the structural principle from Opposing Forces. Concentrations of power generate counter-forces proportional to the concentration. Peripheral groups unite against the dominant power, one of them eventually becomes dominant, and the cycle repeats. Same mechanism, different substrate.
Interference completeness is the real termination determinant (refined 2026-05-18). The first reading of this thread put weight on hidden-random information as the termination kill switch. The sharper reading: what determines whether an N≥3 game terminates under ideal play is interference completeness, not hidden information.
Complete interference (Risk, Diplomacy): the dogpile can fully neutralize a leader’s progress. High-level play treats hidden-random as worst-case-assumed (Risk: “3+ cards AS-IF they already have the turn-in armies”), which collapses the information asymmetry and restores the perfect-info dogpile. Such games terminate only via out-of-game persuasion — convincing opponents to defect from the optimal coalition. Against a perfect AI that doesn’t believe out-of-game promises, neither Risk nor Diplomacy would ever end. This is the structural reason Cicero needed both a planner AND a language model — the language model handles the persuasion the planner can’t fake. ([[cicero-press-diplomacy-captain-meme]] and [[gunboat-diplomacy-diplodocus]] bracket this result: Cicero needs the language layer; Diplodocus pure-planner wins only in Gunboat where persuasion isn’t allowed.)
Incomplete interference (Catan, Poker, Monopoly): the dogpile can throttle progress but not stop it. A channel of advancement continues regardless — Catan’s production-roll, Poker’s forced bet-stream, Monopoly’s mandatory dice. Such games terminate under perfect AI because progress accumulates whether opponents like it or not. Hidden-random adds a timing layer (decides which turn it ends) but is not the structural termination mechanism — that’s the un-suppressible progress stream.
Chris’s one-line summary: “In ideal play, Risk will never end, but Catan will always end.” Interference completeness is the load-bearing knob; hidden information is a timing modulator on top of it.
Practical termination in complete-interference games — bounded rationality. Perfect-AI theory says Risk and Diplomacy should never end. In practice they end every weekend. The mechanism is bounded human rationality, and Risk’s two card-variant designs make this visible: in fixed turn-in Risk (4-6-8-10 style), the card value is bounded and players apply AS-IF worst-case reasoning cleanly, restoring the dogpile — fixed Risk preserves deadlock and ends via persuasion. In escalation Risk (linear +5 per turn-in, unbounded — …, 30, 35, 40, …, reaching 1000+ armies only after ~200 turn-ins in a long game), the linear growth is mechanically trivial but humans anchor on the recent past rather than re-pricing the cumulative, and over a long game attention erodes — escalation Risk ends via anchoring-bias + cognitive-fatigue failures, not strategy. Against a perfect AI that re-anchors correctly each turn, escalation Risk would also stall. These games are designed for humans, not for perfect agents. Their termination mechanisms (persuasion, anchoring failure) are bounded-rationality exploits; strip the bound and the game reverts to deadlock. This is the structural reason Cicero’s language model is required — the LM is the bounded-rationality interface for the persuasion that terminates complete-interference games.
See Catan 47k empirical — N≥3 termination for the full treatment with the game-class comparison table.
Monopoly adds layers of complexity that make the coalition problem even harder:
What was tried:
What went wrong:
What Monopoly needs:
The local optimum wall revealed the core problem: the AI was evaluating trades in absolute terms (does this property make me richer?) rather than relative terms (does this trade improve my position against the field?).
A critical distinction for understanding what EPT actually measures:
Dice-EPT is exogenous income — Go salary, Chance cards, Community Chest, certain square effects. This is new money entering the system from “outside.” If no player owned any property and everyone just rolled dice, dice-EPT is the only income. All players would have roughly the same dice-EPT, and net worth would grow at the same rate for everyone. No differentiation.
Property-EPT is endogenous transfer — rent. When someone lands on your property, your net worth increases and theirs decreases by the same amount. Property-EPT is zero-sum. It creates no new value; it redistributes existing value between players.
The global interest rate is the sum of all players’ dice-EPT — the rate at which total player wealth actually grows. Property development doesn’t change this rate. Building a hotel doesn’t make the pie bigger; it redirects more of the existing flow to you.
Relative position = your total EPT (dice + property) / average EPT of all players. In the no-property baseline, this ratio is 1.0 for everyone — flat, no differentiation. As property gets acquired and developed, the ratios diverge. The whole game is about making your ratio greater than 1.0 at others’ expense.
This means:
Each player’s net worth over time can be graphed as a curve. Total EPT (dice + property) is the slope — the rate at which your position changes per turn. A player with high property-EPT and low cash is on a steep trajectory; a player with high cash and low property-EPT is on a flat one. The graph makes the competitive landscape visible.
The decision criterion changes. Every action — trade, build, hold cash — should be evaluated by how it changes your EPT relative to the field average:
Leadership is the reference frame. Leader identification is easy (EPT calculation is solved math). Once you know who’s ahead on the slope chart, every decision becomes: does this action close the gap between me and the leader, or widen it? The three-player self-balancing dynamic falls out naturally — two players with lower slopes have shared incentive to avoid any trade that steepens the leader’s curve.
The relative position model tells you what to measure (EPT relative to field average) but not how to evaluate individual trades in multiplayer. This is the problem that stalled the Monopoly project.
The trap: You evaluate a trade with the leader in isolation — you gain more property-EPT than they do, so your relative position improves. Good trade. But the leader also makes individually-favorable trades with player 3 and player 4. Each opponent thinks they got the better end. But the leader accumulates some benefit from every trade, and the sum of those small benefits across all trades exceeds any single opponent’s gain. The leader traded with the field and came out ahead against the field, even though they “lost” each bilateral exchange.
This is the coalition problem resurfacing. You cannot evaluate a trade without knowing what other trades the leader is making or might make. And you cannot coordinate with other players to block the leader’s trade strategy without forming a coalition — which is the unsolved problem.
Why atomic evaluation is insufficient: In two-player games, bilateral trade evaluation works — there’s only one opponent, so the bilateral view IS the full view. In multiplayer, every bilateral trade changes the landscape for every other possible trade. The evaluation space isn’t N individual trades — it’s the combination of all trades the leader could execute in a round. That’s combinatorial.
This is the kingmaker problem expressed through trade. The classic kingmaker scenario is “player 3 decides whether player 1 or player 2 wins.” Here the dynamic is inverted: the leader extracts kingmaker-level advantage from the field by exploiting the fact that no single opponent can see or respond to the full pattern of trades. Each player sees only their bilateral exchange and evaluates it as favorable. The collective result is that the field kingmakes the leader without intending to — and without any single player being “wrong” in their individual assessment.
This was the wall. The fudge factors in the Monopoly AI were approximating something about this dynamic — heuristics for “be cautious trading with the leader” or “discount leader-trade gains” — but without the theoretical framework to derive them. The insight is that the solution can’t live at the level of individual trade assessment. It has to operate at the level of trade policy or strategy — rules about patterns of trades, not evaluation of single trades. What that policy looks like is an open problem.
Why the GA couldn’t find this. The GA optimized fudge factors within a model that evaluated trades in isolation. The relative position framework requires evaluating trades against the full competitive landscape — a fundamentally different objective function. Tuning parameters in the wrong model can’t discover the right model. The GA also likely didn’t distinguish between dice-EPT (which it can’t control) and property-EPT (which is the entire strategic lever).
Before building more theory, look at the data. The Monopoly AI’s trade logs and the GA’s tuning history contain empirical evidence about what actually happened — and what didn’t happen.
The pricing puzzle: During GA optimization, trade prices stayed within ~5% of face value across the board. Properties with known EPT advantages (higher landing probability, better rent-to-cost ratios) didn’t command premiums. This doesn’t sit right — it suggests either the valuation model couldn’t express large deviations from face value, or the game states never created enough pressure to move prices.
The most likely explanation: Identical AIs reach similar game states. With the same valuation model, both sides agree on what properties are worth, so there’s no disagreement to drive prices. Price discovery requires genuine difference in assessment — two copies of the same spreadsheet negotiating will converge on face value every time. Self-play with mirrors doesn’t generate the differential needed for price movement.
What to look for in the logs:
The goal is not to “fix the AI” but to use the AI as a laboratory: each fudge factor is an empirical observation about what the theory doesn’t yet explain. Replacing fudge factors with principled rules derived from the interest rate / relative position framework is the real research output. ELO gains may follow, but they’re the lagging indicator — the leading indicator is whether the theory generates the factor’s effect naturally.
Connection to the project pause: The Monopoly project stalled partly because the web client for testing against real opponents couldn’t be built, but more fundamentally because the theoretical framework wasn’t developed enough to know what to test. The relative position model and the fudge factor audit provide a concrete research path that doesn’t require competitive testing — the theory can be developed and validated against the existing AI’s behavior before any external play.
A unifying concept across all three games (and RTS, which makes it real-time):
The interest rate is the rate at which invested resources compound into future capability. It’s not a fixed number — it’s an emergent property of the competitive environment. Your opponent’s strategy determines your effective interest rate because they determine when your investments need to start paying off.
The interest rate dictates input/output matching. A high effective interest rate means you need tight, efficient production chains with minimal waste — every turn’s output must feed next turn’s input cleanly. A low rate gives you slack to be inefficient. The interest rate and the input/output matching problem are two faces of the same underlying dynamic: how efficiently does invested capital compound in a competitive environment?
In competitive games, the interest rate is adversarial. Your opponent is actively trying to manipulate your effective interest rate — forcing you to spend now instead of invest, disrupting your supply lines, raiding your economy to reduce your compounding base. Scouting (in RTS/4X) or reading opponents’ positions (in Monopoly/Risk) is spending resources to reduce uncertainty about what interest rate environment you’re actually in. Without information, you’re making blind bets on time preference — the difference between risk and Knightian uncertainty.
What does “solved” mean for each game?
| Level | Definition | Examples |
|---|---|---|
| Ultra-weakly solved | Outcome from the initial position is known (win/draw/loss) but no strategy is specified | |
| Weakly solved | Optimal play from the initial position can be computed | Checkers (Schaeffer, 2007) |
| Strongly solved | Optimal play from any legal position can be computed | Tic-tac-toe, Connect Four |
| Approximately solved | Near-optimal play is achievable through search + evaluation | Chess (Stockfish), Go (AlphaGo) |
| Computationally irreducible | No shortcut to optimal play — must be simulated/played out | Markets, possibly multiplayer coalition games |
Where Chris’s games fall:
Stockfish’s evolution provides a practical template for Chris’s game AI projects:
Phase 1 — Pure heuristics. Handcrafted evaluation function, alpha-beta search. This is where Slay and Monopoly are now. Good for establishing a baseline and understanding what the evaluation function needs to capture.
Phase 2 — Identify the bottleneck. Is the AI losing because it can’t search deep enough (search problem) or because it misjudges positions (evaluation problem)? In Slay, this is testable: give the AI infinite search depth on small boards and see if it plays perfectly. If yes, the bottleneck is search. If no, the evaluation function is wrong.
Phase 3 — NN evaluation (cyborg split). Replace the handcrafted evaluation with a learned one. Keep the search algorithm. The NN handles pattern recognition over complex game states (what Stockfish’s NNUE does). The search handles systematic exploration (what alpha-beta does). Each component does what it’s best at.
Phase 4 — Multiplayer adaptation. For games beyond two players, the search component needs to change. Alpha-beta assumes a single opponent minimizing your score. With multiple opponents, you need either:
The open question: does the Stockfish architecture generalize to multiplayer games? The NN eval + algorithmic search split should work regardless of player count — the NN evaluates positions, the search explores futures. But the search algorithm itself may need to be fundamentally different for multiplayer dynamics. This is the core research question.
The observation that multiplayer games naturally reduce through phases suggests a decomposition strategy:
Phase 1: Many players (6→4). High chaos, rapid elimination of weak players. Strategy is mostly local — survive, accumulate, exploit mistakes. Leader evaluation is less useful because the “leader” changes rapidly. Heuristic play focused on position and efficiency may be sufficient.
Phase 2: Middle game (4→3). Coalition dynamics intensify. Temporary alliances form and break. Kingmaker situations arise. Leader evaluation matters here — but identifying the leader is not actually the hard problem. These games are mostly perfect information, and calculating the lead is relatively straightforward:
The hard problem in Phase 2 is not who is leading but what to do about it — the coalition response. When and how to pressure the leader, whether to ally with another underdog or go it alone, and how to avoid becoming the kingmaker.
Phase 3: Three-player balance (3→2). The self-balancing dynamic kicks in. The two weaker players pressure the leader. Alliances swap as leadership changes. This phase might be approximately solvable if the balancing dynamic can be formalized — perhaps as a repeated game where the equilibrium strategy is “always oppose the leader.”
Phase 4: Endgame (2→1). Two-player game. Minimax applies. Solved or approximately solved depending on the game.
The research question: Can each phase be solved (or approximately solved) independently, with transitions between phases handled by recognizing when the game state has shifted from one regime to another? If so, the full multiplayer game doesn’t need to be solved — only each phase does, and the phase transitions.
This is similar to how chess engines handle openings (book), middlegame (search + eval), and endgame (tablebases) as distinct problems with different algorithms. The multiplayer version would be: early game (heuristic accumulation), middle game (coalition-aware search), late game (self-balancing leader opposition), endgame (minimax).
The self-balancing prediction is that remaining players converge on opposing whoever is currently leading. In theory, this is each player’s individually-best move. In human practice, it often fails. The reason is grudge-motivation: a player recently wronged targets the wronger rather than the current leader, pulling the coalition off its optimum. Vengeance is often strategically suboptimal but psychologically load-bearing in humans, and the leader can sometimes coast to victory while the other players are busy punishing each other.
Forward-looking-pure agents don’t have the grudge term. Each Cicero in the CaptainMeme-vs-6-Cicero game independently computed “oppose the current leader” as its best move and the bots converged on the target without needing explicit coordination. The self-balancing dynamic executed cleanly in a way it usually doesn’t with humans. That game’s documentation of the “no grudge” signature — a planner-LM composite feature — is concrete evidence that composite AIs can execute multiplayer coalition logic more cleanly than human players.
Scope criterion — where self-balancing holds. Self-balancing requires that opposing the leader be feasible and effective. The game structure must reward coordinated resistance. In Diplomacy, Monopoly, Risk, Slay, and Catan it does — negotiation phases allow coordination, and the leader needs others’ cooperation to extract further resources. In poker it doesn’t — chips are the only resource, the leader has them, coordination isn’t possible between hands, and GTO rewards targeting the weakest player (less room to absorb losses). So the full claim is:
Self-balancing holds when the game structure rewards coordinated resistance against the leader; it fails when the structure rewards targeting weakness instead. Where it does hold, forward-looking-pure agents (planner-LM composites) execute it more reliably than humans because they don’t carry grudges that pull the coalition off optimum.
If N≥3 self-balancing is desirable in some multi-agent system — governance, market, agent team, any coordination problem depending on equilibrium self-correction — forward-looking-pure agents will execute it more cleanly than human agents. This is a genuine AI-design advantage. The Gödel governance problem is partly about why concentration-of-power dynamics resist correction in human institutions; if composite AIs execute the “oppose the leader” logic cleanly where humans don’t, the design space for coordination problems expands.
The catch: someone has to define who “the leader” is, and what “opposing” means, and those definitions are themselves adversarial choices. The advantage only holds inside a well-scoped coordination game where the reward function is clean. That’s the same domain-definition problem the planner-LM composites page identifies for L5/L6 automation generally.
| Work | Author | Relevance |
|---|---|---|
| Theory of Games and Economic Behavior (1944) | Von Neumann & Morgenstern | Foundation of game theory; minimax theorem for two-player zero-sum games |
| Non-Cooperative Games (1950) | John Nash | Nash equilibrium — the solution concept for multiplayer games |
| The Complexity of Computing a Nash Equilibrium (2009) | Daskalakis, Goldberg, Papadimitriou | Proof that computing Nash equilibria is PPAD-complete |
| Mastering Chess and Shogi by Self-Play (2017) | Silver et al. (DeepMind) | AlphaZero — NN eval + MCTS replacing handcrafted heuristics in two-player games |
| Efficiently Updatable Neural-Network-based Eval (2020) | Yu Nasu (Stockfish) | NNUE — the cyborg approach: NN eval inside traditional alpha-beta search |
| Pluribus: Superhuman AI for Multiplayer Poker (2019) | Brown & Sandholm | AI for six-player poker — the closest existing work to the multiplayer coalition problem with hidden information |
| War and Peace and War (2006) | Peter Turchin | Asabiyyah and civilizational cycles — the real-world analogue of the three-player balancing dynamic |
games, game-ai, economics, ai, mathematics, simulation, game-theory