Imported from gabrielmoreira/agent-skills-mirror (mirrors/repos/vasilyu1983@AI-Agents-public/frameworks/shared-skills/skills/foundations-game-theory/SKILL.md). Install upstream with npx skills add gabrielmoreira/agent-skills-mirror --skill foundations-game-theory. Copyright stays with the author.

Game Theory Foundations

22 applied game-theory primitives for strategic decision systems, backed by a formal theory map. Each applied primitive solves a specific incentive or coordination failure. Primitives are domain-agnostic: the same mechanism that prevents free-riding in agent teams prevents cost-shifting in partnership contracts; the same auction that routes tasks routes ad placements.

For the agent-team applied recipe layer (team.yaml manifest fields, agent-team anti-patterns, agent-team decision checklist, composition recipes for typical agent-team scenarios), see agents-subagents/references/game-theory-agent-teams.md.

Contents

• Quick Reference
• Primitive Index
• Formal Supporting Theory
• Expert Judgment: When the Model Helps vs Misleads
• Anti-Patterns
• Misuse Boundaries
• Decision Checklist
• Composition Recipes
• Workflow
• ASCII Flow
• Current Pattern Review
• Navigation
• Fact-Checking

Quick Reference

When to Apply

Apply game-theory primitives when:

• Multiple agents/teams/users with potentially divergent incentives
• Synthesis where minority-correct outcomes matter (high-stakes, irreversible)
• Auctions, bidding, mechanism design, or pricing where strategic behaviour exists
• Repeated interactions where reputation, cooperation, or trust evolves
• Best-of-N selection across 5+ candidates (BMV/RCS)
• Cross-trust delegation, dynamic agent pools, or high-stakes act/escalate decisions

Skip and use simpler alternatives when:

• Single agent / single-shot task — game theory is about interactions, not solo work
• Routine task with high majority-correct rate — a deterministic check or oracle is cheaper
• Hard verification exists (test suite, schema, calculator) — use the oracle, not voting
• Team < 3 members on a low-stakes call — overhead exceeds diversity gain
• Information-only retrieval / pure compression — use foundations-information-theory instead
• Single-system reliability/SLO question — use foundations-reliability-theory or queueing-theory

Primitive Index

Each primitive has a full playbook (problem, solution, how-it-works, launch-prompt template, domain applications, citations).

Formal Supporting Theory

The 22 primitives are the applied layer, not the whole field. Use references/formal-theory-map.md when the task needs formal assumptions, proof obligations, or classical theory coverage.

Expert Judgment: When the Model Helps vs Misleads

Applying a primitive correctly is mechanical. Knowing whether the game-theoretic frame is the right frame at all — and which game — is the actual expert skill. This section is judgment, not a lookup table.

The equilibrium selection problem

Most interesting games (repeated games especially — see the Folk Theorem in formal-theory-map.md) have many equilibria, not one. A non-expert computes an equilibrium and reports it as "the" prediction. An expert checks multiplicity first and asks what actually selects among the candidates in this specific situation — precedent, an explicit contract, a public commitment, a focal point, or repeated-play reputation. Reporting "the Nash equilibrium is X" without naming the selection mechanism is a tell that the analysis stopped one step too early.

Common-knowledge assumptions failing in practice

Nash equilibrium, Bayesian Nash equilibrium, and most mechanism-design proofs assume common knowledge of rationality, of payoffs (or their distribution), and of the rules of the game itself. Real organizations violate all three routinely:

• A "competitor" may be a satisficer bound by an internal OKR or a legacy contract, not a profit-maximizing best-responder — modeling them as rational invites a confidently wrong prediction.
• Bidders or negotiating parties often do not share a common prior on value — private information about downstream use, not risk attitude, is driving the gap.
• LLM agents do not reliably best-respond at all: pro-social bias, framing sensitivity, and authority compliance are documented, repeated deviations from Nash play (see the LLM rationality trap in patterns-scenarios-traps.md). Any incentive-compatibility argument built on "agents best-respond" needs a held-out behavioral check before it is trusted for LLM participants.
• The deviation runs in both directions, and over-truthfulness breaks proofs the same way strategic misreporting does. LLM agents in matching markets reveal preferences truthfully at higher rates than human subjects, but truth-telling does not track strategy-proofness — a strategy-proof mechanism did not elicit more truthful reports than a manipulable one (Hoshino, Kitadai & Nishino, arXiv:2606.03030, June 2026). Mechanism-based markets still beat free negotiation on stability and efficiency; the conclusion is that matching theory is a useful but incomplete guide for LLM-agent institutions, not that the guarantees transfer.

Self-assessment is the binding constraint on agent markets. Auctions, task routing (#3), and confidence staking (#11) all consume agent self-reports of cost and success probability. MarketBench (Fradkin & Krishnan, arXiv:2604.23897, April 2026) measured six recent models on 93 SWE-bench Lite tasks and found them poorly calibrated on both success rate and token consumption; auctions built from those self-reports diverged from the full-information allocation, and supplying prior-capability context improved calibration only modestly. Before routing real work by agent bids, measure calibration on held-out tasks — an incentive-compatible mechanism fed miscalibrated valuations allocates badly without anyone misreporting strategically.

Habit: before invoking a solution concept, ask "would every party recognize this as the same game I do?" If not, either model it explicitly as a game of incomplete information (Bayesian game) or drop equilibrium language and use the frame as a heuristic only.

Mapping a business situation to the right game

Non-experts reach for "prisoner's dilemma" or "Nash equilibrium" as a generic label for any tense multi-party situation. An expert asks a short sequence of diagnostic questions before naming a game form or picking a primitive:

1. Who are the real strategic actors? Not every interested party is a strategic player — a regulator reacting on a multi-year lag is closer to an exogenous constraint than a player in a weekly pricing game.
2. One-shot or repeated — do the players expect to meet again? A single vendor negotiation is a bargaining problem (#12); an ongoing supplier relationship is a repeated game where reputation and folk-theorem-style cooperation are available — analyzing it as one-shot recommends defection that is actually irrational given the relationship's shadow of the future.
3. Simultaneous or sequential, and who commits first? Prices set quarterly and observed by competitors before they respond is closer to Stackelberg (sequential, first-mover) than Cournot/Bertrand (simultaneous) — the right model changes the recommendation from "best-respond" to "commit and signal."
4. Is value created cooperatively or contested? Cooperative-game tools (Shapley, core) fit attribution and surplus-sharing (#4); competitive tools (auctions, Nash) fit contested allocation (#3, #9). Applying auction logic to a joint-venture split, or Shapley logic to a zero-sum negotiation, produces answers that are precise and wrong.
5. Is there a credible commitment device? A threat or promise only constrains behavior if the counterparty believes it will be carried out even against the threatener's own later interest. A pricing "war" threat with no sunk cost or public commitment behind it is cheap talk — treat it as information about intent, not as a binding constraint on the game tree.
6. Is this actually a game, or an oracle-verifiable fact? The most common non-expert error in this whole domain is running a debate, auction, or negotiation protocol over a question that has a deterministic answer — a test suite, a contract clause, a calculator. See Misuse Boundaries.

Mechanism-design failure modes that only surface in production

Textbook mechanism design proves existence of a truthful, efficient, individually rational mechanism under an idealized participant model. Each row below is a normal way real deployments break that idealization — not an edge case to footnote.

Practical tell: if a mechanism is called "truthful" or "incentive-compatible" but nobody can name (a) the participation constraint being satisfied, (b) how false identities are prevented, (c) who absorbs budget imbalance, and (d) what enforces the rules other than the prompt, the claim has not actually been checked.

Communication channels are a collusion dial, not a neutral feature. Direct seller-to-seller messaging raises collusive tendency in simulated continuous double auctions, with the effect varying by model and modulated by oversight and authority pressure (Agrawal et al., arXiv:2507.01413, 2025). The same channel that reduces conflict in coordination games raises coordinated overpricing in market games — decide which game you are actually running before granting agents a side channel.

Anti-Patterns

Misuse Boundaries

Decision Checklist

• Routing: Is the problem multi-option with measurable fit signal? → auction (#3)
• Attribution: Does the output depend on contributions from multiple sources? → Shapley (#4)
• Aggregation: Does synthesis combine claims with varying quality? → reasoning-tree audit (#13) + mechanism-design synthesis (#7)
• Trust calibration: Are participants heterogeneous in track record? → reputation gating (#5)
• Tradeoff detection: Are there multiple incommensurable objectives? → Pareto-Nash (#9) or negotiation (#12)
• High-stakes binary decision: Needs evidential audit trail? → courtroom debate (#8)
• Adversarial context: Claims may be injected or manipulated? → per-claim credibility scoring (#14)
• Multi-stakeholder output: Multiple user types with different needs? → generative social choice (#15)
• Prediction / forecast: Confidence calibration required? → prediction market (#11)
• Long-running coordination rule: Has a measurable quality signal over many runs? → evolutionary coordination search (#10)
• Multi-party context-sharing risk: Members may produce overlapping analysis? → belief-driven coordination (#1)
• Best-of-N synthesis (discrete answer): Need to recover minority-correct? → BMV (#18)
• Best-of-N synthesis (open-ended): Lexically diverse but semantically clustered candidates? → RCS (#19)
• Repeated team optimization: 50+ runs with measurable contribution signal? → online Shapley prompt evolution (#17)
• Debate role-fit ambiguity: Best plaintiff/defense not the obvious specialist? → meta-debate role routing (#16)
• High-stakes act/escalate: Debate agreement is not enough? → conformal social choice (#20)
• Cross-trust delegation: Delegate can self-claim quality or authority? → attested delegation contract (#21)
• Large team topology: 6+ members or distinct workstreams? → coalition formation routing (#22)

Composition Recipes

See assets/templates/game-theory/README.md for full domain-scenario stacks.

Quick stacks:

• Pricing / monetization: #9 (Pareto-Nash for objective mapping) + #12 (BATNA/ZOPA for negotiation range) + #7 (synthesis dissent required) Inputs: Competitor price points, own marginal cost, demand elasticity estimate, switching cost for buyer. Rules: Map Pareto frontier across price/margin/volume objectives (#9); compute BATNA floor and ZOPA ceiling per party (#12); run Bertrand floor check — if product is undifferentiated, price collapses to marginal cost; differentiation (feature, brand, lock-in) is required to hold above floor; synthesis must surface dissenting price band (#7). Outputs: Price band (floor = marginal cost or BATNA, ceiling = ZOPA upper bound), differentiation requirement to sustain above-floor pricing, dissent note if any Pareto-dominated option was preferred by a stakeholder.

• Ad bidding / task routing: #3 (auction routing) + #4 (Shapley ROI attribution) + #11 (confidence-weighted forecast) Inputs: Bidder count, valuation distribution (private or correlated), bid visibility (sealed vs. open), budget constraints. Rules: If private values and bids sealed → 2nd-price (Vickrey) dominant; if bids are publicly visible → 1st-price + reserve (visible bids flip incentive to overbid for signalling, collapsing the 2nd-price guarantee); attribute ROI across winning bidder's components via Shapley marginal contribution; calibrate confidence forecasts via CritiCal step before staking. Outputs: Mechanism choice (1st-price + reserve vs. 2nd-price), expected revenue estimate, per-component Shapley ROI attribution, calibrated confidence interval on forecast.

  Worked example — marketplace switching from 1st-price to 2nd-price (Vickrey) auction. Bidders: 4, valuations [10, 8, 6, 4]. 1st-price equilibrium: rational bid shading produces bids ≈ [7.5, 6, 4.5, 3] → revenue = 7.5 (winner pays own bid). 2nd-price truthful: bids = [10, 8, 6, 4] → revenue = 8 (winner pays 2nd-highest). Truthfulness gain: +6.7% revenue, plus zero bid-shading complexity → fewer abandoned bids and lower ops cost. Anti-pattern: don't run 2nd-price with publicly visible bids — incentive flips to overbid for signalling and the dominant-strategy guarantee collapses.

• Security / adversarial context: #14 (per-claim credibility) + #13 (reasoning-tree audit) + #8 (courtroom for go/no-go) Inputs: Claim set under review, evidence sources per claim, adversarial threat model (injection vector, attacker capability), go/no-go decision stakes. Rules: Score each claim independently on evidence quality × corroboration weight (#14); trace every claim to its First Point of Disagreement in the reasoning tree (#13); run courtroom plaintiff/defense/judge only after per-claim scoring — debate over unsupported claims amplifies uncertainty rather than resolving it. Outputs: Per-claim credibility score, reasoning-tree audit trail, go/no-go recommendation with dissent preserved, list of claims that failed credibility threshold and require retrieval before re-evaluation.

• Partnership design: #6 (cooperation-defection payoff test) + #5 (reputation gating) + #12 (ZOPA negotiation) Inputs: Partner track record (prior-interaction count n, defection incidents), payoff matrix cells for cooperation vs. defection on the proposed arrangement, each party's BATNA and stated interests. Rules: If n < 3 interactions → require contractual escrow or clawback clause (iterated PD cannot be relied on with insufficient history); if n ≥ 3 and no defection → tit-for-tat sufficient; assign reputation tier (probationary / standard / proven) based on defection rate and interaction depth (#5); locate ZOPA as overlap between each party's reservation value and walk-away point (#12); flag if no ZOPA exists — do not negotiate, renegotiate the scope. Outputs: Recommended contract structure (escrow clause if n < 3, tit-for-tat terms if n ≥ 3), reputation tier assigned, ZOPA range or no-deal flag, payoff-scale test result (cooperation dominant or defection dominant under current incentives). If an LLM runs the negotiation: do not accept deal rate as the success metric — it saturates across frontier models while surplus extraction, belief calibration, and constraint compliance still diverge sharply (TERMS-Bench, arXiv:2605.13909, 2026, 13 systems). Score surplus captured against the counterpart's latent payoff, and treat a high close rate with low surplus as conceding, not winning.

• High-quality synthesis: #13 (reasoning-tree audit) + #7 (mechanism-design synthesis) + #11 (confidence betting) Inputs: Candidate outputs or claims, evidence source per claim, participant confidence estimates, synthesis stakes (reversible vs. irreversible decision). Rules: Audit reasoning tree to First Point of Disagreement before aggregating (#13); require dissent as a mandatory section in synthesis output (#7); run CritiCal calibration on participant confidence before staking (#11) — overconfident participants otherwise dominate. Outputs: Synthesized recommendation with dissent section, per-claim evidence trace, calibrated confidence interval, list of unresolved disagreements requiring further evidence.

• High-stakes act/escalate: #13 (reasoning-tree audit) + #11 (confidence elicitation) + #20 (conformal social choice) Inputs: Candidate actions, member probability distributions, calibration table or shadow-case history, escalation cost. Rules: Treat agreement as evidence, not proof; pool distributions; act only when the calibrated prediction set is singleton; escalate when the set has multiple plausible answers. Outputs: Singleton action or escalation reason, prediction set, confidence/calibration note, evidence that would shrink the set.

• Cross-trust delegation: #21 (attested delegation contracts) + #3 (auction routing) + #5 (reputation gating) Inputs: Delegate pool, attested capabilities, authority boundary, acceptance criteria, failure policy. Rules: Filter by verified capability before any bidding; never route by self-claimed quality; give the winner a bounded contract; update reputation only from verified outcomes. Outputs: Eligible delegate set, chosen delegate, delegation contract, typed failure/recovery path, reputation update.

• Large-team coalition routing: #22 (coalition formation) + #1 (belief-driven coordination) + #4 (coalition-level Shapley) Inputs: Workstreams, member capabilities, dependency map, synthesis owner, deadline. Rules: Form stable coalitions around workstreams; run local coalition analysis first; synthesize coalition leads rather than every raw member output; check that no load-bearing workstream is unowned. Outputs: Coalition map, local findings, cross-coalition conflicts, final synthesis.

• Multi-party teams (always-on baseline): #1 (belief-driven coordination) + #4 (Shapley) + #7 (synthesis with required dissent) Inputs: Team member count, context overlap risk (do members share the same documents/signals?), contribution measurability (can each member's marginal value be isolated?). Rules: Assign each member a unique belief lane to break pooling equilibrium (#1); compute Shapley marginal-contribution score per member per run (#4); synthesis must include dissent section — loudest-wins aggregation is the default failure mode (#7). Outputs: Belief lane assignment per member, Shapley contribution scores, synthesized output with dissent preserved, free-rider flag if any member's marginal contribution is near zero.

• Best-of-N (discrete answer): #18 (BMV) — Optimal Weight + Inverse Surprising Popularity Inputs: N candidate answers (discrete), per-candidate confidence score, calibration data if available. Rules: Weight each candidate by confidence × calibration accuracy (Optimal Weight); apply Inverse Surprising Popularity to recover minority-correct answers that majority vote would suppress; do not apply if a hard oracle (test suite, schema check, calculator) is available — use the oracle directly. Outputs: Selected answer with weighted score, runner-up with score delta, flag if minority-correct candidate was recovered.

• Best-of-N (open-ended generation): #19 (RCS) — embedding-centroid selector across 5+ candidates Inputs: 5+ candidate generations (open-ended text), embedding model, semantic similarity threshold. Rules: Embed all candidates; compute centroid; select candidate closest to centroid as representative; do not use lexical-overlap voting — semantically equivalent answers split the vote under lexical scoring. Outputs: Selected generation (centroid-nearest), semantic cluster map, outlier candidates flagged for manual review if they are far from centroid but potentially high-value.

• High-frequency team optimization: #4 (Shapley) + #17 (online Shapley prompt evolution) + #5 (reputation gating) Inputs: Run count (minimum 50 for meaningful Shapley signal), per-member contribution measurability, current prompt set per member. Rules: Compute Shapley contribution per member per run (#4); use Shapley signal to guide per-member prompt mutation each epoch (#17); gate autonomy by accumulated reputation tier — probationary members get tighter review until track record reaches standard tier (#5); do not apply online Shapley prompt evolution below 50 runs — signal is too noisy for reliable mutation. Outputs: Updated prompt per member (mutated toward higher Shapley contribution), reputation tier per member, contribution trend chart (improving / stable / degrading).

• Building a multi-agent LLM application (full-stack recipe): #1 (belief-driven coordination) + #21 (attested delegation) + #5 (reputation gating) + #20 (conformal act/escalate) + #4 (Shapley attribution) Inputs: Agent pool (roles, capabilities, trust provenance), task decomposition map, reversibility of downstream actions, success metric per agent. Rules: Assign belief lanes at design time so agents receive differentiated context and cannot pool into a uniform analysis (#1); route sub-tasks only to delegates with attested (not self-claimed) capability — the provenance paradox shows self-claimed routing performs worse than random (#21); start every new agent on probationary tier; promote to standard tier only after 3+ verified successful runs (#5); before any irreversible action (payment, send, deploy), check that the conformal prediction set is singleton — multi-answer set triggers human escalation (#20); compute Shapley marginal contribution per agent per release epoch to detect free-riders and guide prompt or architecture revision (#4). Anti-pattern: do not run a flat panel of 6+ agents — form coalitions by workstream first (#22). Outputs: Belief-lane assignment per agent, attested-capability registry, reputation tier per agent, act/escalate gate policy, Shapley contribution report per epoch, coalition map if team ≥ 6.

Navigation

• Per-mechanism playbooks: assets/templates/game-theory/ (one file per primitive)
• Composition guide: assets/templates/game-theory/README.md
• Formal theory map: references/formal-theory-map.md
• Current patterns, scenarios, and traps: references/patterns-scenarios-traps.md
• Domain-agnostic primitives overview: references/primitives-overview.md
• Sources: data/sources.json

Current Pattern Review

Use references/patterns-scenarios-traps.md before applying a primitive to production or agent-team routing. It distinguishes durable game-theory mechanisms from fast-moving LLM-agent papers, lists scenario-specific stacks, and calls out traps such as majority-vote collapse, uncalibrated confidence, static role assignment, overusing debate, and source claims that have not been rechecked against primary papers.

Workflow

1. Identify the strategic failure mode in your system (attribution, routing, synthesis, trust, negotiation, adversarial risk).
2. Use the Quick Reference table to map failure mode → primitive.
3. Open the per-mechanism playbook in assets/templates/game-theory/ for the full problem/solution/launch-prompt template.
4. For multi-failure scenarios, use the Composition Recipes or the full assets/templates/game-theory/README.md to stack primitives.
5. Check references/patterns-scenarios-traps.md for trap coverage before shipping the mechanism.
6. For agent-team applied recipes (team.yaml manifest fields, agent-team anti-patterns, decision checklist for team launches), load agents-subagents/references/game-theory-agent-teams.md.
7. For other domain applied recipes — pricing, paid advertising, CRO, security, market intel — see each domain skill's references/game-theory-applied.md (or game-theory-pricing.md for startup-business-models).

ASCII Flow

Strategic interaction or incentive failure
  -> Identify actors, payoffs, information, and repeatedness
  -> Classify failure: attribution, routing, synthesis, trust, negotiation, adversarial risk
  -> Select applied mechanism
     +-- shared payoff only -> consider team theory instead
     +-- divergent incentives -> continue with game-theory primitive
  -> Check formal assumptions and pattern traps
  -> Produce mechanism, launch rule, evidence requirement, and fallback

Related Skills

• agents-subagents — agent-team applied recipes: team.yaml manifest fields, agent-team anti-patterns, decision checklist
• marketing-paid-advertising — paid auction recipes (GSP/VCG, bid shading, budget pacing)
• startup-business-models — pricing recipes (VCG, Hotelling, Folk Theorem, signaling)
• marketing-cro — experimentation recipes (Thompson, MAB, sequential testing)
• software-security-appsec and qa-security-testing — defender/attacker recipes (Stackelberg, honeypots)
• startup-market-intel — competitive recipes (Stackelberg, Bertrand, Cournot, Hotelling positioning)

Fact-Checking

• Verify paper results (accuracy deltas, token counts) against primary arxiv sources before treating them as benchmarks.
• Mechanism effectiveness is task- and domain-specific. Test on a held-out sample before deploying at scale.
• Source links and verified dates in each per-mechanism file are the canonical evidence tier.
• If web access is unavailable, mark runtime-specific claims as unverified.

Learnings Loop

Before applying this skill on a non-trivial task, read learnings.consolidated.md in this directory (and learnings.md if present).

After applying it, if you encountered a pattern worth remembering, a mistake worth preventing, or a domain fact that surprised you, append one dated bullet to learnings.md via agents-skills-feedback-loop/scripts/append_learning.py. Do not modify SKILL.md itself.