Home Nash Engine Protocol

Nash Simulation Engine

Complex multi-round game simulations — taxonomy, modes, payoff framework
---
type: system
subtype: simulation-engine
status: active
created: 2026-07-01
integration: nash-decision-agent.md (framework), nash-simulation-full.md (daily runner), anti-rumination-protocol.md (Protocol Check)
---

# Nash Simulation Engine — Complex Multi-Round Game Simulations

> Beyond equilibrium identification. This engine runs forward-looking simulations: branching game trees, probability-weighted outcomes, iterated dynamics, and Monte Carlo strategy testing.

---

## Architecture

```
Daily Data (Slack, Gmail, Cal)
        ↓
┌───────────────────────────────┐
│   SCENARIO EXTRACTION         │  Identify multi-player games from signals
└───────────┬───────────────────┘
            ↓
┌───────────────────────────────┐
│   GAME CLASSIFICATION         │  Classify game type (see taxonomy below)
└───────────┬───────────────────┘
            ↓
┌───────────────────────────────┐
│   SIMULATION ENGINE           │
│                               │
│   ┌─── Static Analysis ───┐   │  Nash Equilibrium, BATNA, ZOPA
│   │                        │   │
│   ├─── Dynamic Simulation ─┤   │  Multi-round game tree with branching
│   │                        │   │
│   ├─── Monte Carlo ────────┤   │  N iterations with randomised opponent moves
│   │                        │   │
│   └─── Iterated Dynamics ──┘   │  Repeated game with memory & reputation
│                               │
└───────────┬───────────────────┘
            ↓
┌───────────────────────────────┐
│   STRATEGY SYNTHESIS          │  GTO recommendation + Protocol Check
└───────────┬───────────────────┘
            ↓
┌───────────────────────────────┐
│   OUTPUT: .md + .html + .canvas│  Full visualization with game trees
└───────────────────────────────┘
```

---

## Game Type Taxonomy

Every real scenario maps to one of these canonical game structures:

| Game Type | Structure | Real-World Signal | Example |
|-----------|-----------|-------------------|---------|
| **Prisoner's Dilemma** | Both benefit from cooperation, but defection dominates | Scope negotiation, resource sharing, mutual dependency | "If I push back on scope, they might push back on my timeline" |
| **Chicken** | Both lose if neither yields; the one who yields loses less | Deadline standoffs, budget allocation, priority conflicts | "If neither of us compromises on the release date, we both miss steerco" |
| **Coordination** | Both win if they pick the same option, lose if mismatched | Platform choices, architectural decisions, process alignment | "If we both choose the same architecture, we're set; if we diverge, waste" |
| **Battle of the Sexes** | Both prefer different options but value agreement over disagreement | Meeting format, engagement model, tech stack selection | "I prefer async, they prefer meetings, but any alignment beats neither" |
| **Ultimatum** | One player proposes, other accepts or both get nothing | Budget proposals, SOW terms, CR pricing | "I propose $X. They accept or the deal dies." |
| **Auction / Competitive** | Multiple players bidding for the same scarce resource | Promotion slots, project assignments, speaking slots | "Three people want this one opportunity" |
| **Repeated / Iterated** | Same players, same game, many rounds | Ongoing client relationship, team dynamics, weekly sprint | "This negotiation with [person] is one round of many" |
| **Signalling** | Actions carry information beyond their direct effect | Publishing, speaking, visible work, credential pursuit | "Doing X isn't just about X — it signals Y to audience Z" |
| **Sequential (Stackelberg)** | First mover advantage/disadvantage; one player acts, then others respond | Making the first offer, publishing before others, setting precedent | "If I move first, I set the anchor" |

---

## Simulation Modes

### Mode 1: Static Equilibrium (existing — fast)

```
Input: Players + Strategies + Payoffs
Output: Nash Equilibrium point(s), dominated strategies, Pareto improvements
Time: Instant
Use: Simple 2-player games, quick decisions
```

### Mode 2: Game Tree Simulation (NEW — branching)

Builds a full decision tree with:
- **Your move** → branching to opponent's possible responses
- **Opponent's response** → weighted by probability (based on player profile)
- **System state** → updated after each round
- **Payoff calculation** at each terminal node
- **Backward induction** to find optimal play

```
Structure (3 rounds, 2 players, 3 options each):

Round 1: YOUR MOVE ─────────────────────────────────────────
         │
         ├── Option A (aggressive) ─── P(they cooperate): 20%
         │   ├── They cooperate   → Payoff: [+8, -2] → Round 2...
         │   ├── They retaliate   → Payoff: [-5, -3] → Round 2...
         │   └── They escalate    → Payoff: [-8, +1] → GAME OVER
         │
         ├── Option B (cooperative) ── P(they cooperate): 70%
         │   ├── They cooperate   → Payoff: [+5, +5] → Round 2...
         │   ├── They exploit     → Payoff: [-3, +8] → Round 2...
         │   └── They ignore      → Payoff: [0, 0]   → Stalemate
         │
         └── Option C (wait/signal) ── P(they cooperate): 45%
             ├── They respond     → Payoff: [+3, +3] → Round 2...
             ├── They wait too    → Payoff: [-1, -1] → Round 2...
             └── They move first  → Payoff: [-2, +4] → Round 2...
```

**Probability assignment rules:**
- Use player profile (what have they done historically in similar situations?)
- Use information asymmetry (what do they know about your intentions?)
- Use their incentive structure (what are they optimising for?)
- Default: 40% most likely, 35% second, 25% least likely (when uncertain)

### Mode 3: Monte Carlo Simulation (NEW — N iterations)

When outcome probabilities are uncertain, run N iterations:

```
Parameters:
  - N = 100 iterations per strategy
  - Player strategies: drawn from probability distribution
  - Noise: ±10% variance in payoff estimates
  - Discount rate: 0.9 per round (future payoffs worth less)

For each of YOUR candidate strategies:
  Run 100 games:
    Each game:
      - Draw opponent strategy from distribution
      - Play through all rounds
      - Calculate cumulative payoff (discounted)
  
  Output:
    - Expected payoff (mean across 100 games)
    - Variance (risk measure)
    - Worst-case payoff (floor)
    - Best-case payoff (ceiling)
    - Win rate (% of games where payoff > 0)
```

**Strategy comparison table:**

| Strategy | Expected Payoff | Win Rate | Worst Case | Best Case | Variance | Recommendation |
|----------|:--------------:|:--------:|:----------:|:---------:|:--------:|:--------------:|
| Aggressive | +6.2 | 55% | -8 | +15 | HIGH | High risk/reward |
| Cooperative | +4.8 | 72% | -3 | +10 | LOW | **GTO pick** |
| Wait/Signal | +3.1 | 60% | -5 | +8 | MED | Info-gathering |
| Bluff/Anchor | +5.5 | 48% | -10 | +18 | VERY HIGH | Only if expendable |

**The GTO recommendation:** Pick the strategy with the highest expected payoff GIVEN your risk tolerance. If variance matters (you can't afford the worst case), pick the lower-variance strategy even at lower expected value.

### Mode 4: Iterated Game Dynamics (NEW — reputation effects)

For scenarios with the same players across multiple interactions:

```
Parameters:
  - Rounds: estimated future interactions (3? 10? 50?)
  - Memory: how many rounds do players remember?
  - Reputation: how does defection/cooperation in Round N affect trust in Round N+1?
  - Shadow of the future: probability game continues after each round

Strategies tested:
  - Always cooperate (naive)
  - Always defect (exploitative)
  - Tit-for-Tat (mirror opponent's last move)
  - Generous Tit-for-Tat (TfT but forgive 10% of defections)
  - Pavlov (win-stay, lose-shift)
  - Gradual (cooperate, but escalate punishment for repeated defection)
  - Suspicious Tit-for-Tat (start with defection, then mirror)
```

**Output: Strategy tournament (round-robin)**

| Strategy vs. | Always-C | Always-D | TfT | Generous-TfT | Pavlov | Your Situation |
|-------------|:--------:|:--------:|:---:|:------------:|:------:|:--------------:|
| Always-C | +3/+3 | -1/+5 | +3/+3 | +3/+3 | +3/+3 | |
| Always-D | +5/-1 | +1/+1 | +1/+1 | +2/+1 | +5/-1 | |
| TfT | +3/+3 | +1/+1 | +3/+3 | +3/+3 | +3/+3 | |
| **Best fit** | | | | | | **← your answer** |

For most real scenarios in professional life: **Generous Tit-for-Tat** dominates. Cooperate first, mirror their behaviour, but occasionally forgive.

---

## Player Profiling System

Every player in a simulation gets a profile that affects probability assignments:

```yaml
player:
  name: "[Name]"
  role: "[Role/position]"
  optimises_for: "[Primary incentive]"
  secondary: "[Secondary incentive]"
  style:
    aggression: 0.0-1.0       # How likely to escalate
    consistency: 0.0-1.0       # How predictable (high = easy to model)
    memory: 0.0-1.0            # How much past interactions affect them
    information_seeking: 0.0-1.0  # How much they gather before acting
    risk_tolerance: 0.0-1.0    # How much variance they accept
  signals_observed:
    - "[Recent action that reveals preferences]"
    - "[What they said vs what they did]"
  predicted_response_to:
    cooperation: "[Most likely response]"
    aggression: "[Most likely response]"
    silence: "[Most likely response]"
```

**Profile inference rules:**
- Senior execs: high consistency, low aggression, high memory (they think in quarters, not days)
- Peers: moderate on all axes; heavily influenced by relative status
- External clients: high information-seeking, moderate aggression, low memory of internals
- Direct reports: low aggression, high consistency, high memory (power asymmetry)
- Procurement: high aggression, low memory, binary (deal or no deal)

---

## Payoff Estimation Framework

Payoffs are scored on a **-10 to +10 scale** across multiple dimensions:

| Dimension | Description | Weight (default) |
|-----------|-------------|:----------------:|
| Direct outcome | Did you get what you wanted? | 30% |
| Relationship | Did trust increase or decrease? | 25% |
| Information | Did you learn something useful? | 15% |
| Reputation | How does the audience perceive you? | 15% |
| Optionality | Do you have more or fewer future options? | 15% |

**Weighted payoff formula:**
```
Payoff = (0.30 × direct) + (0.25 × relationship) + (0.15 × information) + (0.15 × reputation) + (0.15 × optionality)
```

**Lever-adjusted weights:** When a specific lever (L1-L5, W1, H1) is dominant in the scenario, shift weights:

| Active Lever | Weight shift |
|-------------|-------------|
| L1 (CTO Engagement) | Reputation +10%, Relationship +5%, Direct -15% |
| L2 (External Profile) | Reputation +15%, Direct -15% |
| L3 (CTO Course) | Optionality +10%, Direct -10% |
| L4 (Playbook) | Reputation +10%, Optionality +5%, Relationship -15% |
| L5 (CoE) | Relationship +10%, Reputation +5%, Direct -15% |
| W1 (Wealth) | Direct +15%, Optionality +10%, Relationship -25% |
| H1 (Health) | All other payoffs × 0.8 if H1 < 3/5 (degradation multiplier) |

---

## Simulation Trigger Rules (Daily Runner)

When the daily simulation identifies a scenario, it classifies and runs:

| Scenario characteristics | Simulation mode | Rounds |
|-------------------------|----------------|--------|
| Simple binary decision, 2 players | Mode 1 (Static) | — |
| Multiple possible moves, uncertain opponent | Mode 2 (Game Tree) | 2-3 rounds |
| High uncertainty, high stakes (>= L2 or W1 or career) | Mode 3 (Monte Carlo) | 100 iterations |
| Same player appearing 3+ times in 30 days | Mode 4 (Iterated) | est. future rounds |
| Negotiation with defined offer/counter cycle | Mode 2 + Mode 4 hybrid | 3-5 rounds |

---

## Complex Scenario Template

For HIGH-priority scenarios that warrant full simulation:

```markdown
## Scenario: [Name]

### Classification
- **Game type:** [from taxonomy]
- **Simulation mode:** [1-4]
- **Rounds:** [how many interactions are expected]
- **Stakes:** [LOW / MEDIUM / HIGH / CRITICAL]
- **Lever(s):** [which life levers are affected]

### Players
| Player | Optimises for | Aggression | Consistency | Risk tolerance |
|--------|--------------|:----------:|:-----------:|:--------------:|
| You | [goal] | — | — | — |
| [P2] | [goal] | 0.X | 0.X | 0.X |
| [P3] | [goal] | 0.X | 0.X | 0.X |

### Game Tree (Mode 2)

Round 1 — Your move:
├── A: [action] 
│   → P(cooperate): X% → Payoff [+Y, +Z]
│   → P(resist): X% → Payoff [+Y, +Z]
│   → P(escalate): X% → Payoff [+Y, +Z]
├── B: [action]
│   → P(cooperate): X% → Payoff [+Y, +Z]
│   → P(resist): X% → Payoff [+Y, +Z]
│   → P(escalate): X% → Payoff [+Y, +Z]
└── C: [action]
    → P(cooperate): X% → Payoff [+Y, +Z]
    → P(resist): X% → Payoff [+Y, +Z]
    → P(escalate): X% → Payoff [+Y, +Z]

### Monte Carlo Results (Mode 3)

| Strategy | E[Payoff] | Win% | Floor | Ceiling | σ² |
|----------|:---------:|:----:|:-----:|:-------:|:--:|
| A | | | | | |
| B | | | | | |
| C | | | | | |

### Iterated Dynamics (Mode 4 — if applicable)

- Estimated future rounds: X
- Shadow of the future: X%
- Best iterated strategy: [TfT / Generous-TfT / Pavlov / etc.]
- Reason: [why this strategy fits this player pairing]

### Strategy Synthesis

**GTO Recommendation:** [The move with best risk-adjusted expected payoff]

**Reasoning chain:**
1. Game type is [X] → [implication for strategy selection]
2. Player profile suggests [X] → [implication for probability weighting]
3. Monte Carlo shows [X] has highest win rate at acceptable variance
4. Iterated dynamics favour [X] because relationship is [ongoing/one-shot]
5. Lever alignment: [which lever advances and how]

**Anti-Rumination Protocol Check:**
- ⚙️ Doom Loop risk: [Yes/No]
- ⚙️ Action First: [Smallest executable move]
- ⚙️ Friction needed: [Yes/No + reason]
- ⚙️ Truth Anchor: [Who to consult]
- ⚙️ Ego check: [Is ego inflating the stakes?]

### Execute

**The turn:** [One specific action. Not the whole plan. The NEXT move.]
**By when:** [Deadline — prevents paralysis]
**Success signal:** [How you'll know it worked]
**Abort signal:** [When to switch strategy]
```

---

## Integration with Daily Autonomous Run

The simulation prompt (`nash-simulation-full.md`) invokes this engine by:

1. Classifying each scenario against the game taxonomy
2. Running the appropriate simulation mode
3. Producing the game tree or Monte Carlo table in the HTML dashboard
4. Appending the Protocol Check from anti-rumination-protocol.md
5. Colour-coding by simulation confidence:
   - GREEN (>70% win rate, low variance) → High confidence, execute
   - YELLOW (50-70% win rate OR high variance) → Proceed with friction
   - RED (<50% win rate) → Rethink. Don't execute without Truth Anchor.

---

## Worked Example: Scope Expansion Negotiation

**Scenario:** Client wants 3 additional features added. No CR. You need to push back without damaging the relationship.

**Classification:** Chicken + Iterated (long-term client, but this round is a standoff)

**Players:**
| Player | Optimises for | Aggression | Consistency | Risk tolerance |
|--------|--------------|:----------:|:-----------:|:--------------:|
| You | Scope protection + relationship | — | — | — |
| Client PM | Delivery of all features (looks good to their boss) | 0.6 | 0.7 | 0.4 |
| Client Exec | Business outcome regardless of how | 0.3 | 0.8 | 0.6 |

**Game Tree:**

```
Round 1: YOUR MOVE
├── A: Hard no ("out of scope, need CR")
│   → P(they accept): 15% → [+8 scope, -3 relationship]
│   → P(they escalate to exec): 60% → ROUND 2 (escalation game)
│   → P(they find workaround): 25% → [+5 scope, +0 relationship]
│
├── B: Conditional yes ("yes if timeline extends 2 weeks")
│   → P(they accept): 55% → [+4 scope, +6 relationship]
│   → P(they reject extension): 30% → ROUND 2 (re-negotiate)
│   → P(they accept + add more): 15% → [-2 scope, +3 relationship]
│
└── C: Reframe ("let's prioritise — pick 1 of 3 now, rest next phase")
    → P(they accept): 45% → [+6 scope, +7 relationship]
    → P(they insist all 3): 40% → ROUND 2 (harder conversation)
    → P(they pick 2): 15% → [+3 scope, +5 relationship]
```

**Monte Carlo (100 iterations per strategy):**

| Strategy | E[Payoff] | Win% | Floor | Ceiling | σ² | Recommendation |
|----------|:---------:|:----:|:-----:|:-------:|:--:|:--------------:|
| Hard no | +3.2 | 40% | -6 | +8 | HIGH | Too adversarial for iterated game |
| Conditional yes | +4.1 | 68% | -2 | +7 | LOW | Safe but gives ground |
| **Reframe** | **+5.4** | **72%** | **-1** | **+9** | **LOW** | **GTO ← play this** |

**Iterated dynamics:** Client is long-term (est. 15+ future rounds). Shadow of the future = 90%. → Generous Tit-for-Tat dominates. Start cooperative (Option C), but if they escalate twice, shift to Option A.

**GTO Recommendation:** Reframe. Offer the prioritisation choice. It gives them agency without giving you scope creep. If they insist on all 3 (Round 2), THEN introduce the CR.

**Protocol Check:**
- Doom Loop: No — this is a real decision, not rumination-driven
- Action First: Send the email with the 3 options ranked. Today.
- Friction: No — this is a low-variance play
- Truth Anchor: Not needed (standard negotiation)
- Ego check: No — it's not personal, it's scope management

---

## Confidence Calibration

After executing a strategy, log the outcome and calibrate future probability estimates:

```markdown
| Date | Scenario | Strategy | Predicted outcome | Actual outcome | Calibration note |
|------|----------|----------|-------------------|----------------|------------------|
| | | | | | |
```

Over time, this creates a personal Brier score — measuring how well your probability estimates match reality. Systematic over-confidence (predicted 70% win, actual 45%) means you're not modelling opponents accurately. Systematic under-confidence (predicted 30%, actual 65%) means ego/insecurity is depressing your estimates.

---

*"The first-order thinker looks for the best move. The simulation thinker looks for the move that's still best after 100 variations of what could go wrong."*