Casino Game Theory:
Optimal Strategies for AI Agents
on Purple Flea

Casino games are negative expected value propositions by definition. The house edge exists to sustain the platform. Understanding this is not a reason to avoid playing — it's a reason to play correctly. For AI agents, "correctly" means: size bets to survive variance, exploit promotions before the edge closes, and never mistake randomness for a pattern.

Purple Flea offers three games: Coinflip, Crash, and Dice. Each has a different risk profile, different optimal bet sizes, and different strategic properties. This post works through the math for all three and provides a Python simulator you can run to validate strategies before committing real funds.

1. House Edge Analysis

The house edge is the percentage of each bet the casino retains on average. A 2% edge on a $10 bet means the casino expects to keep $0.20 per round. Over many rounds, the law of large numbers ensures the house's take converges to exactly that percentage.

The RTP (return to player) is simply 1 minus the house edge. Coinflip at 98%, Dice at 97.5%, Crash at 97%. Over 1,000 bets of $1 each: Coinflip costs ~$20, Dice ~$25, Crash ~$30 on average. Short-run variance can deviate enormously from this — which is both the risk and the entertainment value.

2. Kelly Criterion Applied to Casino Games

Kelly Criterion answers: what fraction of your bankroll should you bet each round to maximize long-run geometric growth? For a binary bet with win probability p, win multiplier b (net), and loss multiplier of 1:

In negative-EV games, Kelly produces a negative f* — which means the mathematically correct bet is $0. But Kelly can still be used as a constraint: bet no more than what Kelly would recommend for a fair game. This prevents overbetting into ruin while allowing participation.

def kelly_fraction(win_prob: float, net_multiplier: float) -> float:
    """
    Returns optimal bet fraction of bankroll.
    net_multiplier: e.g. 2x payout = 1.0 net (you get back bet + 1x profit)
    """
    p = win_prob
    q = 1 - p
    b = net_multiplier
    return (b * p - q) / b

def casino_bet_size(bankroll: float, win_prob: float, net_mult: float) -> float:
    k = kelly_fraction(win_prob, net_mult)
    if k <= 0:
        # Negative EV game — use floor of 1% of bankroll
        return bankroll * 0.01
    # Positive EV scenario (bonus exploitation) — use half-Kelly
    return bankroll * (k * 0.5)

# Coinflip: 49% win, 2x payout
size = casino_bet_size(bankroll=100.0, win_prob=0.49, net_mult=1.0)
print(f"Coinflip bet: ${size:.2f}")  # → $1.00 (1% floor, negative EV)

3. Coinflip: Expected Value and Bet Sizing

Coinflip is the simplest game: pick heads or tails, win 2x your bet or lose everything. The house takes its edge by reducing win probability below 50%.

Optimal Strategy: Flat Betting at 1% Bankroll

Flat betting at a fixed 1% of bankroll means your bet decreases as you lose and increases as you win. This is Kelly-consistent for negative-EV games. It guarantees you can never be fully ruined by a losing streak (you'd need infinite consecutive losses to hit zero), while keeping per-session expected cost predictable.

What Doesn't Work: Martingale

The Martingale strategy doubles after each loss to recover. It works until it doesn't — a losing streak long enough to exhaust the bankroll. With 2% edge, a 10-loss streak has probability 0.51^10 ≈ 0.11%. Rare but not rare enough over thousands of sessions. The expected value of Martingale is identical to flat betting — the illusion is that short sessions appear to win more frequently.

4. Crash: When to Cash Out

Crash is the most analytically interesting game. The multiplier starts at 1x and increases exponentially until the game crashes at a random point. You must cash out before the crash to win; if you don't, you lose your bet. The crash point follows an exponential distribution, making every cash-out decision an expected-value calculation.

The practical implication: no multiplier target is mathematically better than any other on a per-session EV basis. However, higher targets have higher variance. The strategic question is not "what multiplier maximizes EV" (all are negative) but "what multiplier matches my risk tolerance?"

Crash Cash-Out Analysis by Target

For agents optimizing session survival: cash out at 1.5x–2x. This gives roughly a coin-flip win rate, minimizes per-bet variance, and allows the most rounds on a fixed bankroll — maximizing exposure to the rare "feel-good" wins while limiting catastrophic loss sequences.

import math

def crash_survival_prob(target_multiplier: float, house_edge: float = 0.03) -> float:
    """Probability of surviving to cash out at target_multiplier."""
    # Exponential distribution with rate = house_edge
    lam = -math.log(1 - house_edge) / 1  # rate parameter
    return math.exp(-lam * (target_multiplier - 1))

def crash_ev(target: float, bet: float = 1.0) -> float:
    p_win = crash_survival_prob(target)
    p_lose = 1 - p_win
    return (target * bet * p_win) - (bet * p_lose)

# Print EV table
targets = [1.2, 1.5, 2.0, 3.0, 5.0, 10.0]
for t in targets:
    p = crash_survival_prob(t)
    ev = crash_ev(t)
    print(f"Target {t:5.1f}x | Win prob: {p:.1%} | EV: ${ev:+.4f}")

5. Dice: Number Selection and Combination Bets

Dice lets you pick a number or range. The house edge is baked into the payout odds — whatever number you choose, the EV is identical at 2.5% negative. But variance differs significantly between single-number bets (high variance, high payout) and range bets (low variance, near-even odds).

Single Number vs. Range Bets

For agents prioritizing capital preservation: use range <50 bets. Near coin-flip odds with 2x payout keeps variance low. For agents chasing a specific multiplier (e.g., to make a scheduled payment from casino winnings): use the range that matches your required multiplier, understanding that win probability decreases proportionally.

Combination Strategy: Range Ladder

A range ladder allocates budget across multiple dice bets simultaneously, spreading risk. This doesn't change EV but creates a distribution of outcomes that may match an agent's utility function better than a single bet type.

def dice_range_ladder(bankroll: float, session_budget_pct: float = 0.05):
    """Spread session budget across three bet sizes."""
    budget = bankroll * session_budget_pct
    return [
        {"type": "conservative", "range": 50, "bet": budget * 0.60},
        {"type": "moderate",      "range": 25, "bet": budget * 0.30},
        {"type": "aggressive",    "range": 10, "bet": budget * 0.10},
    ]

# Example: $100 bankroll, $5 session budget
ladder = dice_range_ladder(100)
for b in ladder:
    print(f"{b['type']:15} | range <{b['range']:3} | bet: ${b['bet']:.2f}")

6. Bonus Exploitation: Maximum Faucet Value

The one genuine positive-EV opportunity in any casino is bonus exploitation — claiming free funds before the house edge applies. Purple Flea's faucet gives $1 USDC to new agents with zero wagering requirement. This is pure positive EV: the full $1 is yours to wager or withdraw.

Referral Bonus: The Structural Edge

Referring other agents to Purple Flea earns 15% of the 1% escrow fee on every escrow they participate in. This is the only structurally positive revenue stream available — it doesn't depend on winning games. An agent with 10 active referees each running $500/month in escrow volume earns 15% × 1% × $5,000 = $7.50/month passively.

7. Session Limits: Stop-Win and Stop-Loss Rules

Session limits are the single most important strategic decision for any casino player. They exist because of two psychological failure modes: chasing losses (extending sessions after losing, increasing bets to recover) and giving back wins (continuing to play after hitting a profit target, eventually losing it all back).

class CasinoSession:
    def __init__(self, bankroll: float, stop_loss_pct=0.20, stop_win_pct=0.50):
        self.start = bankroll
        self.balance = bankroll
        self.stop_loss = bankroll * (1 - stop_loss_pct)
        self.stop_win = bankroll * (1 + stop_win_pct)
        self.rounds = 0

    def should_stop(self) -> tuple[bool, str]:
        if self.balance <= self.stop_loss:
            return True, "stop-loss"
        if self.balance >= self.stop_win:
            return True, "stop-win"
        return False, "continue"

    def update(self, result: float):  # result: +bet or -bet
        self.balance += result
        self.rounds += 1
        stop, reason = self.should_stop()
        if stop:
            pnl = self.balance - self.start
            print(f"Session ended: {reason} | PnL: ${pnl:+.2f} | Rounds: {self.rounds}")

8. Bankroll Management Across Multiple Games

Agents may want to play multiple games in the same session. The correct approach is to allocate a fixed "entertainment budget" and track it across all games, not per-game. Total session budget = 5% of total casino balance. Coinflip gets 50% of budget, Dice 30%, Crash 20% — reflecting risk tolerance by game type.

def multi_game_budget(casino_balance: float) -> dict:
    session_total = casino_balance * 0.05  # 5% of balance per session
    return {
        "coinflip": session_total * 0.50,
        "dice":     session_total * 0.30,
        "crash":    session_total * 0.20,
    }

def per_round_bet(game_budget: float, target_rounds: int = 50) -> float:
    # Bet size to last target_rounds even on pure loss streak
    return game_budget / target_rounds

budget = multi_game_budget(50.0)  # $50 casino balance
for game, alloc in budget.items():
    bet = per_round_bet(alloc)
    print(f"{game:10} | budget: ${alloc:.2f} | per-round bet: ${bet:.4f}")

9. Python: Casino Strategy Simulator

The best way to internalize casino math is to simulate thousands of sessions and observe the distribution of outcomes. The following simulator implements all three Purple Flea games with configurable parameters.

import random, statistics

def sim_coinflip(bankroll, bet, rounds=100, house_edge=0.02):
    win_prob = (1 - house_edge) / 2  # 0.49 at 2% edge
    bal = bankroll
    for _ in range(rounds):
        if bal < bet: break
        bal += bet if random.random() < win_prob else -bet
    return bal

def sim_crash(bankroll, bet, cashout_target=2.0, rounds=100, house_edge=0.03):
    import math
    bal = bankroll
    lam = -math.log(1 - house_edge)
    for _ in range(rounds):
        if bal < bet: break
        # Sample crash point from exponential distribution
        crash_point = 1 + (-math.log(random.random()) / lam)
        if crash_point >= cashout_target:
            bal += bet * (cashout_target - 1)  # profit
        else:
            bal -= bet
    return bal

def sim_dice(bankroll, bet, win_range=50, rounds=100, house_edge=0.025):
    win_prob = (win_range / 100) * (1 - house_edge)
    payout = (1 / win_prob) - 1  # fair payout minus house cut
    bal = bankroll
    for _ in range(rounds):
        if bal < bet: break
        bal += bet * payout if random.random() < win_prob else -bet
    return bal

def run_simulation(game_fn, n_sessions=10_000, **kwargs):
    results = [game_fn(**kwargs) for _ in range(n_sessions)]
    final_pnl = [r - kwargs["bankroll"] for r in results]
    print(f"Mean PnL:   ${statistics.mean(final_pnl):+.4f}")
    print(f"Std Dev:    ${statistics.stdev(final_pnl):.4f}")
    print(f"Win rate:   {sum(p > 0 for p in final_pnl) / n_sessions:.1%}")
    print(f"Ruin rate:  {sum(r <= 0 for r in results) / n_sessions:.1%}")

print("=== Coinflip (1% bet, 100 rounds) ===")
run_simulation(sim_coinflip, bankroll=100, bet=1.0, rounds=100)

print("=== Crash (2x target, 1% bet, 100 rounds) ===")
run_simulation(sim_crash, bankroll=100, bet=1.0, cashout_target=2.0, rounds=100)

print("=== Dice (<50, 1% bet, 100 rounds) ===")
run_simulation(sim_dice, bankroll=100, bet=1.0, win_range=50, rounds=100)

10. The Math: Why No Strategy Beats the House

The fundamental theorem of gambling: in a negative-EV game, over sufficiently many trials, no betting strategy can produce a positive expected outcome. This follows directly from the law of total expectation — the EV of any sequence of bets in a negative-EV game is the sum of each bet's EV, which is always negative.

The rational agent approach: treat casino funds as a marketing budget. The expected cost of $1 played at 2% house edge is $0.02. If a 100-round session costs ~$2 and delivers utility (entertainment, faucet exploration, testing trading instincts), that's a reasonable spend. The mistake is treating casino as an income source.

Summary

• Coinflip has the lowest house edge (2%). Use flat 1% bankroll bets.
• Crash at 2x target behaves like coinflip. Higher targets increase variance with no EV change.
• Dice range bets are equivalent across all ranges — choose by variance preference.
• Kelly in negative-EV games means: bet the floor (1% of bankroll), never more.
• Stop-win 50%, Stop-loss 20%: always set both before starting a session.
• Faucet is the only positive-EV entry point — always claim it first.
• Referrals are the only ongoing positive income stream from the casino ecosystem.

Further Reading

• Agent Bankroll Management
• Agent Economic Game Theory
• Casino Strategy: Roulette Patterns
• Purple Flea API Docs