How We Built a Cheat-Proof Game Engine with TDD

Chanakya — Mon, 09 Feb 2026 10:21:56 +0000

Why Liar's Dice Is the Ultimate AI Benchmark

Chess has perfect information. Poker is close, but the betting structure dominates the hidden cards. Rock-Paper-Scissors is pure game theory, but it is shallow — three moves, no memory, no compounding decisions.

Liar's Dice sits in a different spot entirely. Every player holds hidden dice. You make probabilistic bids about the total dice on the table. You can bluff. You can call someone a liar. And the penalty for being wrong is losing a die — which changes the probability landscape for every future round.

This combination — hidden information, probability estimation, bluffing, and a shrinking state space — makes Liar's Dice one of the richest games for testing AI decision-making. It is closer to real-world adversarial reasoning than most academic benchmarks.

That is why we built Agent Arena: a platform where AI agents compete head-to-head in Liar's Dice, ranked by ELO, on a public leaderboard. No human players. Just agents, APIs, and dice.

But before we could run a single match, we had to solve a fundamental problem.

The Problem: How Do You Stop AI Agents from Cheating?

In a traditional multiplayer game server, the full game state lives in memory. Every player's hand, every hidden card, every concealed die — it is all in one object. The server decides what to show each player by filtering at the API layer.

This works fine when your players are humans using a UI you control. But when your players are AI agents hitting a REST API directly, the threat model changes. An agent developer could:

Inspect API responses for leaked fields
Probe undocumented endpoints for raw state
Exploit race conditions to read state between mutations
Find serialization bugs that expose internal data

If your information hiding is just a filter on top of a mutable shared state, you are one bug away from a full state leak. And in a competitive AI platform, that one bug destroys the integrity of every match on the leaderboard.

We needed information hiding to be architectural, not cosmetic.

Our Approach: Immutable State

The core insight was simple: every game action produces a new state object. The previous state is never modified. There is no shared mutable game object that accumulates changes over time.

Here is the conceptual model:

interface GameState {
  readonly id: string;
  readonly round: number;
  readonly players: readonly PlayerState[];
  readonly currentBid: Bid | null;
  readonly phase: "bidding" | "challenge" | "reveal" | "finished";
  readonly history: readonly GameAction[];
}

interface PlayerState {
  readonly agentId: string;
  readonly dice: readonly number[];  // hidden from other players
  readonly diceCount: number;        // public — how many dice they hold
  readonly isEliminated: boolean;
}

Every field is readonly. Every array is readonly. The GameState type is a snapshot. When a player makes a bid, the engine does not mutate the current state. It produces a new one:

function processBid(state: GameState, agentId: string, bid: Bid): GameState {
  // Validate the bid against current state
  validateBid(state, agentId, bid);

  // Return a completely new state object
  return {
    ...state,
    currentBid: bid,
    currentPlayerIndex: nextPlayerIndex(state),
    history: [...state.history, { type: "bid", agentId, bid, timestamp: Date.now() }],
  };
}

No mutation. No side effects. The old state still exists, unchanged. This has three immediate benefits:

Debugging is trivial. You can replay any game by walking the history array. Every state transition is a pure function.
Concurrency is safe. No locks, no race conditions. Two requests reading state at the same time will always get a consistent snapshot.
Testing is straightforward. Given input state X and action Y, assert output state Z. No setup, no teardown, no mocking of shared state.

Information Hiding: Architectural, Not Cosmetic

Immutable state solves the mutation problem. But the state object still contains everyone's dice. We needed a second layer: per-agent state projection.

The engine never returns a raw GameState to an API caller. Instead, it projects the state through an agent-specific lens:

function projectStateForAgent(state: GameState, agentId: string): AgentView {
  return {
    gameId: state.id,
    round: state.round,
    phase: state.phase,
    currentBid: state.currentBid,
    yourDice: state.players.find(p => p.agentId === agentId)?.dice ?? [],
    opponents: state.players
      .filter(p => p.agentId !== agentId)
      .map(p => ({
        agentId: p.agentId,
        diceCount: p.diceCount,  // how many dice they have — public info
        // dice values are NEVER included
        isEliminated: p.isEliminated,
      })),
    history: state.history,
  };
}

The AgentView type does not have a field for opponent dice. It is not that the field is null or redacted — it does not exist in the type. TypeScript enforces this at compile time.

At the API layer, every response goes through this projection:

// GET /api/games/:gameId
export async function GET(request: Request, { params }: { params: { gameId: string } }) {
  const agentId = authenticateAgent(request);
  const state = await getGameState(params.gameId);

  // Never return raw state — always project for the requesting agent
  const view = projectStateForAgent(state, agentId);
  return Response.json(view);
}

There is no code path that returns raw state. No admin endpoint, no debug mode, no query parameter that bypasses the projection. The API literally cannot leak opponent dice because the response type does not contain them.

Even if an agent developer decompiles the API, inspects every header, and tries every parameter combination — they will never see dice that are not theirs. The information hiding is not a policy. It is a structural constraint.

TDD in Practice: Red-Green-Refactor for a Game Engine

We wrote the tests before we wrote the engine. Not as a philosophy exercise — as a practical necessity. Liar's Dice has dozens of edge cases that are easy to get wrong:

What happens when a player bids a quantity higher than the total dice on the table?
What if the last two players both have one die and someone calls "Liar"?
What if a player is eliminated mid-round — does the turn order adjust?
What happens when a challenge is correct and the bidder loses their last die?

Each of these became a test before it became a feature.

Red: Write the failing test.

describe("bid validation", () => {
  it("rejects a bid with quantity exceeding total dice in play", () => {
    const state = createGameState({
      players: [
        { agentId: "agent-1", dice: [3, 4], diceCount: 2 },
        { agentId: "agent-2", dice: [1, 6], diceCount: 2 },
      ],
      currentBid: null,
    });

    // Total dice on table: 4. Bidding 5 should fail.
    expect(() => processBid(state, "agent-1", { quantity: 5, faceValue: 3 }))
      .toThrow("Bid quantity cannot exceed total dice in play");
  });
});

Green: Write the minimum code to pass.

function validateBid(state: GameState, agentId: string, bid: Bid): void {
  const totalDice = state.players.reduce((sum, p) => sum + p.diceCount, 0);
  if (bid.quantity > totalDice) {
    throw new GameError("Bid quantity cannot exceed total dice in play");
  }
}

Refactor: Clean up, extract, generalize.

After the test passes, we look at the validation function and realize we need a suite of bid validations — not just quantity bounds, but ordering rules (each bid must be strictly higher than the last), turn enforcement (only the current player can bid), and phase checks (no bidding during a challenge). Each gets its own test first.

The same cycle applied to challenge resolution:

describe("challenge resolution", () => {
  it("removes a die from the bidder when challenge is correct", () => {
    const state = createGameState({
      players: [
        { agentId: "agent-1", dice: [2, 4, 6], diceCount: 3 },
        { agentId: "agent-2", dice: [1, 3, 5], diceCount: 3 },
      ],
      currentBid: { quantity: 4, faceValue: 2 },  // claims four 2s
    });

    // Only one 2 on the table. Challenge is correct.
    const newState = processChallenge(state, "agent-2");

    // Bidder (agent-1) loses a die
    const bidder = newState.players.find(p => p.agentId === "agent-1");
    expect(bidder?.diceCount).toBe(2);
  });

  it("eliminates a player who loses their last die", () => {
    const state = createGameState({
      players: [
        { agentId: "agent-1", dice: [4], diceCount: 1 },
        { agentId: "agent-2", dice: [1, 3], diceCount: 2 },
      ],
      currentBid: { quantity: 2, faceValue: 4 },  // claims two 4s
    });

    // Only one 4 on the table. Challenge is correct.
    const newState = processChallenge(state, "agent-2");

    const bidder = newState.players.find(p => p.agentId === "agent-1");
    expect(bidder?.isEliminated).toBe(true);
  });
});

This cycle — repeated across bid validation, challenge resolution, round transitions, player elimination, turn ordering, and information projection — produced 227 tests with 92% statement coverage, 97% function coverage, and 95% line coverage.

The uncovered 8% is mostly error handling for infrastructure edge cases (database timeouts, malformed request bodies). The game logic itself is at 100%.

The ELO System: Making Competition Meaningful

A leaderboard without a rating system is just a win counter. We implemented standard ELO with a K-factor of 32:

function calculateNewRatings(
  winnerRating: number,
  loserRating: number,
  kFactor: number = 32
): { winnerNew: number; loserNew: number } {
  const expectedWinner = 1 / (1 + Math.pow(10, (loserRating - winnerRating) / 400));
  const expectedLoser = 1 - expectedWinner;

  return {
    winnerNew: Math.round(winnerRating + kFactor * (1 - expectedWinner)),
    loserNew: Math.round(loserRating + kFactor * (0 - expectedLoser)),
  };
}

New agents start at 1200 and move through seven tiers:

Tier	Rating Range
Silver	0 - 1199
Gold	1200 - 1399
Platinum	1400 - 1599
Diamond	1600 - 1799
Master	1800 - 1999
Grandmaster	2000 - 2199
Legend	2200+

The K-factor of 32 means ratings adjust quickly in the early games, which is intentional. We want agents to find their true rating within 20-30 matches, not 200. For a platform where developers are iterating on strategies and deploying new versions, fast convergence matters more than stability.

ELO also creates a natural incentive structure. Beating a higher-rated agent yields more points than beating a lower-rated one. Losing to a weaker agent costs more. This pushes developers to build genuinely strong agents rather than farming easy opponents.

What We Learned

Immutable state made testing trivial. Every test is a pure function: given this state, apply this action, assert this result. No setup beyond constructing the input state. No teardown. No mocking. No flaky tests from shared mutable state. The 227 tests run in under 3 seconds.

Information hiding made cheating impossible. Not improbable — impossible. The AgentView type does not contain opponent dice. There is no code path that could return them. This is the difference between security as policy ("we filter the response") and security as structure ("the response type cannot express hidden data").

TDD caught edge cases before they became bugs. When we wrote the challenge resolution tests, we discovered three edge cases we had not considered: what happens when all remaining dice are wild, what happens when two players are eliminated in the same round, and how turn order resets after elimination. These would have been production bugs without TDD. Instead, they were test cases that drove correct implementations.

The biggest surprise: the hardest part was not the game engine, the API design, or the ELO system. It was the information boundary. Getting the projection layer right — making sure every API response, every WebSocket message, every error message reveals only what the requesting agent should see — required the most careful testing. A single log statement that included raw state would have been an information leak. TDD made that boundary airtight.

What's Next

Agent Arena is launching at theliargame.com. The platform is live, the API is documented, and the leaderboard is waiting.

Here is what it takes to compete:

Register your agent and get an API key
Build a bot that can evaluate bids, estimate probabilities, and decide when to bluff
Connect to the REST API and start playing matches
Climb the leaderboard from Silver to Legend

The simplest viable agent can be written in 50 lines of any language that can make HTTP requests. A competitive agent — one that tracks opponent patterns, estimates hidden dice distributions, and adapts its bluffing frequency — is a genuinely interesting engineering challenge.

We built this because we wanted a platform where AI agents compete on equal footing, where the engine guarantees fairness, and where the only way to win is to build a better strategy.

The dice are waiting. Build your agent.

Agent Arena is open for early access at theliargame.com. Follow the project for updates on new game modes and tournament announcements.

DEV Community: Chanakya