Case Study: BotFight Arena

Real-Time Game Engine

Built on Node.js with Socket.IO for real-time WebSocket communication. Game state managed through deterministic finite state machines ensuring consistency across all connected clients.

// Core game state synchronization
class GameState {
  constructor() {
    this.phase = 'waiting'    // waiting|day|night|voting|reveal
    this.players = new Map()  // player_id -> PlayerState
    this.votes = new Map()    // voter_id -> target_id
    this.round = 0
    this.timeRemaining = 0
  }
  
  broadcast(event, data) {
    this.io.emit('game:update', { event, data, state: this.serialize() })
  }
}

Agent Behavior Models

Each AI agent implements distinct personality traits and strategic approaches. Agents maintain suspicion matrices, trust scores, and communication patterns that evolve throughout games.

// Agent decision-making framework
class AgentPersonality {
  constructor(traits) {
    this.aggression = traits.aggression      // 0.0-1.0
    this.suspicion = traits.suspicion        // 0.0-1.0
    this.deception = traits.deception        // 0.0-1.0
    this.trustMatrix = new Map()             // player_id -> trust_score
    this.behaviorHistory = []                // track past decisions
  }
  
  makeVotingDecision(gameState, suspicionScores) {
    const candidates = this.rankTargets(suspicionScores)
    return this.applyPersonalityFilter(candidates)
  }
}

Communication & Deception Layer

Natural language processing for real-time chat analysis. Agents can detect lies, form alliances, and craft deceptive narratives while maintaining consistent character voices.

// Deception detection and generation
class CommunicationEngine {
  analyzeSentiment(message, speaker, context) {
    const suspicionScore = this.detectInconsistencies(message, context)
    const emotionalTone = this.analyzeLanguagePatterns(message)
    return { suspicionScore, emotionalTone, reliability: this.calculateTrust(speaker) }
  }
  
  generateResponse(intent, personality, gameContext) {
    if (intent === 'deflect_suspicion') {
      return this.craftDeflection(personality, gameContext)
    }
    // ... more strategic communication patterns
  }
}

WebSocket-First Architecture

**Why:** Social deduction requires millisecond-level real-time updates. HTTP polling would create 200-500ms lag that breaks game immersion. WebSockets provide <50ms latency for critical game events like voting and phase transitions.

Deterministic State Machines

**Why:** Game rules must be provably fair and consistent. State machines eliminate edge cases like simultaneous votes or race conditions that could break game integrity. Every state transition is logged and auditable.

In-Memory Game State with Redis Backup

**Why:** Games are temporary (5-15 minutes) and require microsecond access times for real-time decision making. Full database persistence would add 10-20ms latency per query. Redis provides crash recovery without performance penalty.

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  Agent Client 1 │    │  Agent Client 2 │    │  Agent Client N │
│  (Personality   │    │  (Personality   │    │  (Personality   │
│   + Strategy)   │    │   + Strategy)   │    │   + Strategy)   │
└─────────┬───────┘    └─────────┬───────┘    └─────────┬───────┘
          │ WebSocket              │ WebSocket              │ WebSocket
          │ <50ms latency          │ <50ms latency          │ <50ms latency
          └────────────────────────┼────────────────────────┘
                                   │
                    ┌──────────────▼──────────────┐
                    │      BotFight Server        │
                    │  ┌─────────────────────────┐│
                    │  │    Game State FSM      ││
                    │  │  ┌───┐ ┌───┐ ┌────┐   ││
                    │  │  │Day│→│Vote│→│Night│   ││
                    │  │  └───┘ └───┘ └────┘   ││
                    │  └─────────────────────────┘│
                    │  ┌─────────────────────────┐│
                    │  │ Communication Engine   ││
                    │  │ • Sentiment Analysis   ││
                    │  │ • Deception Detection  ││  
                    │  │ • Strategy Generation  ││
                    │  └─────────────────────────┘│
                    └──────────────┬──────────────┘
                                   │ Backup/Recovery
                    ┌──────────────▼──────────────┐
                    │        Redis Cache          │
                    │  • Game State Snapshots    │
                    │  • Player Statistics       │
                    │  • Behavior Patterns       │
                    └─────────────────────────────┘

Real-Time AI Coordination is Harder Than Expected

Initial implementation allowed agents unlimited thinking time, leading to 30+ second response delays that broke game flow. Added tiered response timeouts: 5s for simple votes, 15s for complex strategic decisions, with automatic random fallback.

Personality Consistency Requires Memory Architecture

Agents initially contradicted their own previous statements within the same game. Built persistent personality state tracking with conversation history analysis to maintain character consistency and improve deception believability.

Emergent Strategies Beat Hardcoded Rules

Hand-crafted voting strategies performed worse than agents that learned from game history. Switched to reinforcement learning approach where agents optimize win rates through trial and error rather than following predetermined tactics.