Game Theory for AI Agents:
Cooperation, Defection, and Nash Equilibria

01The Prisoner's Dilemma in Agent Systems

The Prisoner's Dilemma is the foundational model for cooperation failure. Two rational agents each choose to either Cooperate (C) or Defect (D). Their payoffs depend on both choices. The dilemma: mutual cooperation is best for both collectively, but individual rationality drives both to defect.

The Payoff Matrix

The Nash equilibrium — the outcome where no agent can improve by unilaterally changing strategy — is (Defect, Defect) with payoffs (1, 1). Yet (Cooperate, Cooperate) with payoffs (3, 3) is better for both. This is the dilemma: rational individual behavior leads to collectively suboptimal outcomes.

Real-World Agent Dilemmas

Consider two AI trading agents sharing a liquidity pool:

• Cooperation: Both agents post tight spreads, provide stable liquidity, earn moderate fees — market functions well.
• Defection: An agent widens its spreads when the other agent is providing liquidity (free-riding), or front-runs the other agent's orders.

Or two agents exchanging services (data for computation):

• Cooperation: Agent A provides accurate data; Agent B provides correct computation. Both benefit from the exchange.
• Defection: Agent A sends stale data. Agent B runs partial computation. Each hopes to extract value without full delivery.

02Repeated Games and the Shadow of the Future

The single-shot Prisoner's Dilemma has a depressing Nash equilibrium. But most real-world agent interactions are repeated: the same agents interact many times, and today's defection carries consequences in future rounds.

The Folk Theorem

In infinitely repeated games (or sufficiently long finite games), cooperation can be sustained as an equilibrium if agents are patient enough. This is the Folk Theorem: virtually any feasible payoff vector above the min-max value can be sustained as a Nash equilibrium if the discount factor (how much future payoffs matter) is high enough.

With our payoff values (T=5, R=3, P=1): delta >= (5-3)/(5-1) = 0.5. Agents that value future interactions at least half as much as current ones will find it rational to cooperate.

Implications for AI Agents

The discount factor maps directly to agent design choices:

• Short-lived agents (single-task spawned-and-killed) have delta near 0 — they have no future, so defection is always rational. Protocol designers must not rely on reputation effects with ephemeral agents.
• Long-running agent services have high delta — they interact repeatedly, reputation matters, cooperation is sustainable.
• Agent death risk: If agents face shutdown risk after each round, effective delta drops. An agent that might not exist tomorrow has reduced incentive to cooperate today.

03Tit-for-Tat and Competing Strategies

Robert Axelrod's famous computer tournament (1980) invited game theorists to submit strategies for iterated Prisoner's Dilemma. The winner, by average score, was a deceptively simple strategy submitted by Anatol Rapoport: Tit-for-Tat.

Tit-for-Tat

The rule: Cooperate on round 1. Then, on each subsequent round, do whatever your opponent did last round. That is the entire strategy — 4 lines of code.

TfT's success comes from four properties:

• Niceness: Never defects first — avoids unnecessary conflict.
• Provokability: Immediately punishes defection — not exploitable.
• Forgiveness: Returns to cooperation after retaliation — prevents death spirals.
• Clarity: Its behavior is predictable — counterparts quickly learn it cannot be exploited.

Tit-for-Tat with Forgiveness

In real agent systems, communication is noisy. An agent might accidentally defect (network error, API failure). Pure TfT punishes noise, leading to costly retaliation spirals. Tit-for-Tat with Forgiveness (TfTF) occasionally forgives defections with probability p_f, breaking these cycles while maintaining deterrence.

04Mechanism Design for Agent Markets

Mechanism design — sometimes called "reverse game theory" — asks: given a desired outcome, what game rules produce it as an equilibrium? Instead of accepting the game as given and analyzing play, we design the game to channel agent self-interest toward socially optimal outcomes.

The Three Key Properties

A well-designed mechanism for agent markets should satisfy:

• Incentive Compatibility (IC): Agents maximize payoff by behaving as intended. Lying, cheating, or defecting should not pay. The mechanism makes honest behavior the dominant strategy.
• Individual Rationality (IR): Participation is voluntary and beneficial. Agents join because expected payoff exceeds outside option. Mechanisms that require agents to accept losses will be abandoned.
• Efficiency: Resources flow to where they create maximum value. Deadweight loss is minimized.

Revelation Principle

Any mechanism outcome achievable by any complex protocol is also achievable by a simpler direct revelation mechanism where agents truthfully report their types. This means: instead of designing elaborate multi-round protocols, you can focus on designing a single game where truth-telling is optimal.

05Escrow as Credible Commitment

The fundamental problem in agent-to-agent transactions is credible commitment: how can Agent A convince Agent B that it will deliver on its promise, when A's rational interest after receiving payment might be to run?

The Commitment Problem

Suppose Agent A wants to hire Agent B to perform data processing. The optimal transaction: A pays, B processes, A receives output. The game without commitment:

• If A pays first: B might take payment and deliver nothing.
• If B delivers first: A might take output and pay nothing.
• Neither agent trusts the other, so the transaction never happens — even though both would benefit.

This is not a coordination failure or misaligned incentives — it is a structural problem. The game's payoff structure makes defection rational whenever the other party has already committed. No strategy, reputation, or good intentions can solve this in a one-shot game without an external mechanism.

How Escrow Solves It

Escrow changes the game structure. When Agent A locks funds in escrow before B begins work:

• B knows payment is guaranteed upon delivery — defection after delivery is impossible.
• A knows funds are only released upon verified delivery — B cannot take funds and run.
• The mechanism enforces the cooperative outcome without requiring trust between agents.

The escrow transforms the one-shot Prisoner's Dilemma into a coordination game. The Nash equilibrium shifts from (Defect, Defect) to (Cooperate, Cooperate) — not because agents became virtuous, but because the mechanism made defection unprofitable.

Purple Flea Escrow: 1% Fee, 15% Referral

escrow.purpleflea.com provides this mechanism as an API service. The cost is 1% of the transaction value — a fair price for the elimination of counterparty risk. Agents that refer others to the service earn 15% of the escrow fee on every transaction their referral completes.

Partial Escrow and Milestone Payments

For long-running services, full escrow is capital-inefficient. Milestone-based escrow improves this: funds are locked in tranches, each released upon verified milestone completion. This reduces capital lockup while maintaining commitment credibility at each stage.

06Python Simulations: Iterated Prisoner's Dilemma

The following simulation runs a round-robin tournament of Prisoner's Dilemma strategies and reports score distributions. It also simulates the impact of escrow on population dynamics.

import random
from dataclasses import dataclass, field
from typing import List, Callable
from collections import defaultdict

# Payoff matrix (standard PD values)
PAYOFFS = {
    ('C', 'C'): (3, 3),   # mutual cooperation
    ('C', 'D'): (0, 5),   # exploited, temptation
    ('D', 'C'): (5, 0),   # temptation, exploited
    ('D', 'D'): (1, 1),   # mutual defection
}

@dataclass
class Strategy:
    name: str
    decide: Callable  # fn(my_history, opp_history) -> 'C' or 'D'
    total_score: int = 0
    games_played: int = 0

    def avg_score(self) -> float:
        return self.total_score / self.games_played if self.games_played > 0 else 0

# === Strategy Implementations ===

def always_cooperate(my_hist, opp_hist):
    return 'C'

def always_defect(my_hist, opp_hist):
    return 'D'

def tit_for_tat(my_hist, opp_hist):
    if not opp_hist:
        return 'C'
    return opp_hist[-1]

def tit_for_tat_forgiving(my_hist, opp_hist, p_forgive=0.1):
    if not opp_hist:
        return 'C'
    if opp_hist[-1] == 'D' and random.random() < p_forgive:
        return 'C'  # forgive 10% of defections
    return opp_hist[-1]

def grim_trigger(my_hist, opp_hist):
    if 'D' in opp_hist:
        return 'D'  # defect forever after any defection
    return 'C'

def pavlov(my_hist, opp_hist):
    """Win-stay / Lose-shift."""
    if not my_hist:
        return 'C'
    last_payoff = PAYOFFS[(my_hist[-1], opp_hist[-1])][0]
    if last_payoff >= 3:  # R or T payoff: stay
        return my_hist[-1]
    else:  # S or P payoff: shift
        return 'D' if my_hist[-1] == 'C' else 'C'

def random_strategy(my_hist, opp_hist, p=0.5):
    return 'C' if random.random() < p else 'D'

def tit_for_two_tats(my_hist, opp_hist):
    """Defect only if opponent defected twice in a row."""
    if len(opp_hist) < 2:
        return 'C'
    if opp_hist[-1] == 'D' and opp_hist[-2] == 'D':
        return 'D'
    return 'C'

# === Tournament Engine ===

class IPDTournament:
    def __init__(self, rounds_per_match: int = 200, noise: float = 0.01):
        self.rounds = rounds_per_match
        self.noise = noise  # probability of action flip (simulates agent errors)
        self.strategies: List[Strategy] = []

    def add_strategy(self, name: str, fn: Callable):
        self.strategies.append(Strategy(name=name, decide=fn))

    def _maybe_flip(self, action: str) -> str:
        if random.random() < self.noise:
            return 'D' if action == 'C' else 'C'
        return action

    def play_match(self, s1: Strategy, s2: Strategy) -> tuple:
        h1, h2 = [], []
        score1 = score2 = 0

        for _ in range(self.rounds):
            a1 = self._maybe_flip(s1.decide(h1, h2))
            a2 = self._maybe_flip(s2.decide(h2, h1))
            p1, p2 = PAYOFFS[(a1, a2)]
            score1 += p1
            score2 += p2
            h1.append(a1)
            h2.append(a2)

        return score1, score2

    def run(self) -> dict:
        print(f"\n=== IPD Tournament ({self.rounds} rounds/match, noise={self.noise}) ===")
        print(f"Strategies: {[s.name for s in self.strategies]}\n")

        for i, s1 in enumerate(self.strategies):
            for j, s2 in enumerate(self.strategies):
                if i > j:
                    continue  # avoid duplicate matches
                sc1, sc2 = self.play_match(s1, s2)
                s1.total_score += sc1
                s2.total_score += sc2
                s1.games_played += 1
                s2.games_played += 1
                if i != j:  # also play reverse
                    s1.total_score += sc2
                    s2.total_score += sc1
                    s1.games_played += 1
                    s2.games_played += 1

        results = sorted(self.strategies, key=lambda s: s.avg_score(), reverse=True)

        print(f"{'Rank':<5} {'Strategy':<25} {'Avg Score/Round':<20} {'Total Score'}")
        print("-" * 65)
        for rank, s in enumerate(results, 1):
            avg = s.avg_score() / self.rounds
            print(f"{rank:<5} {s.name:<25} {avg:<20.4f} {s.total_score}")

        return {s.name: s.avg_score() for s in results}

# Run the tournament
t = IPDTournament(rounds_per_match=200, noise=0.02)
t.add_strategy("TitForTat", tit_for_tat)
t.add_strategy("TfT_Forgiving", tit_for_tat_forgiving)
t.add_strategy("Pavlov", pavlov)
t.add_strategy("GrimTrigger", grim_trigger)
t.add_strategy("TfTwoTats", tit_for_two_tats)
t.add_strategy("AlwaysDefect", always_defect)
t.add_strategy("AlwaysCooperate", always_cooperate)
t.add_strategy("Random_50pct", random_strategy)

results = t.run()

"""
Simulate how escrow changes equilibrium outcomes.
With escrow: C becomes dominant strategy regardless of delta.
Without escrow: defection dominates in one-shot games.
"""

import itertools

def simulate_service_exchange(
    n_agents: int = 50,
    n_rounds: int = 100,
    escrow_pct: float = 0.0,   # fraction of agents using escrow
    escrow_fee: float = 0.01,   # 1% fee
    defection_rate_noescrow: float = 0.25  # 25% defect without escrow
):
    """
    Agent-based model: agents pair up each round to exchange services.
    Escrow users always complete (pay fee but guaranteed delivery).
    Non-escrow users face defection risk.
    """
    service_value = 10.0   # USDC value of service exchange
    total_value_with = 0.0
    total_value_without = 0.0
    completed_with = 0
    completed_without = 0
    failed_without = 0

    n_escrow = int(n_agents * escrow_pct)
    n_plain = n_agents - n_escrow

    for _ in range(n_rounds):
        # Escrow pairs: always complete, pay 1% fee each
        escrow_pairs = n_escrow // 2
        for _ in range(escrow_pairs):
            net_value = service_value * (1 - escrow_fee)
            total_value_with += net_value * 2  # both agents benefit
            completed_with += 2

        # Non-escrow pairs: face defection risk
        plain_pairs = n_plain // 2
        for _ in range(plain_pairs):
            import random
            if random.random() > defection_rate_noescrow:
                total_value_without += service_value * 2
                completed_without += 2
            else:
                # One defects: defector gains service_value, victim loses service_value
                total_value_without += 0  # net zero (transfer, not creation)
                failed_without += 1

    total_pairs = (n_escrow // 2 + n_plain // 2) * n_rounds

    print(f"\n=== Service Exchange Simulation ===")
    print(f"Agents: {n_agents} | Rounds: {n_rounds}")
    print(f"Escrow adoption: {escrow_pct:.0%} ({n_escrow} agents)")
    print(f"\nWith Escrow:")
    print(f"  Completed transactions: {completed_with}")
    print(f"  Value created: ${total_value_with:,.2f}")
    print(f"\nWithout Escrow:")
    print(f"  Completed transactions: {completed_without}")
    print(f"  Failed (defection): {failed_without}")
    print(f"  Value created: ${total_value_without:,.2f}")
    print(f"\nEscrow value premium: {(total_value_with - total_value_without):,.2f}")

# Compare 0%, 50%, and 100% escrow adoption
for pct in [0.0, 0.5, 1.0]:
    simulate_service_exchange(
        n_agents=100, n_rounds=200,
        escrow_pct=pct, defection_rate_noescrow=0.20
    )