Computer Simulation for Game Design

Faster iterations.
Better games.

Good game design is iterative. The loop of prototype → playtest → evaluate → design is where games get better — but most of it moves at human speed. I build compute simulation systems that handle the mechanical parts of that loop computationally, so designers can spend more time where it matters most: designing.

Prototype Playtest Evaluate Design
Simulation run

Live simulation run — Stepping through a full game of The Beautiful Bid in real time

Stage 01 Prototype Rules → runnable simulation

Turn your rules into
a running simulation.

The first step is encoding your rules as a simulation an AI agent can execute. This means converting your rulebook — however rough — into a structured system where agents can take turns, make decisions, and generate outputs. The act of encoding alone surfaces ambiguities you didn't know were there.

Rule Clarity Issue
The rules around the "Explicit Bribery Windows" were a bit unclear on the first read-through. It would be helpful to have more examples or clarification on when and how these bribery phases are triggered.
Rule Clarity Issue
The resolution order and the president's ability to influence it could also use some additional explanation. It wasn't immediately evident how this could impact the award conditions.
Positive Balance Signal
The corruption mechanic seemed to provide a viable strategy, but the Investigator's ability to audit and penalize it was an effective counterbalance. I didn't feel that any single strategy was overpowered.
Balance Tension
The corruption mechanic provided an interesting strategic avenue, but there were times when it felt overpowered — especially when players could reliably bribe key chairmen for large influence gains.
Watch out for sycophancy: A key challenge in simulation-based playtesting is that agents tend to give overly positive feedback by default. Engineering prompts that surface genuine tension — contradictory feedback from different agents — is critical to getting useful signal. The two conflicting "balance" quotes above are an example of prompting for disagreement.
See raw agent output example

2. Game balance:

– The corruption mechanic seemed to provide a viable strategy, but the

  Investigator's ability to audit and penalize it was an effective

  counterbalance. I didn't feel that any single strategy was overpowered.

Stage 02 Playtest Agents simulate players, turn by turn

Observe how your game
actually flows.

Simulated agents play through your game as distinct characters — each following your rules, making decisions, and traversing game states. Using LangGraph tracing, every turn is logged as a structural map of how your game flows in practice. Designers can see where players hesitate, which rules generate confusion, and which game states are never reached — powerful signal before a single human playtest.

LangGraph state machine trace — agent decision flow across game turns

TURN 1 — game_master_adjudicate_round_start

▸ 5 Chairman spaces (C1–C5) await first bids

▸ Presidency space open for next round's leadership contest

Bidding Phase

▸ First bid on any Chairman space sets that Chairman's vice

▸ Bribe tiles count as 2 bid strength but risk investigation penalties

Flow setup → bidding → investigation → resolution

What this surfaces: By tracing each simulated decision through LangGraph's waterfall view, designers can see exactly where players hesitate, which rules generate clarification questions, and which game states are never reached — powerful signal before a single human playtest.
Stage 03 Evaluate Data-driven balance analysis

Read the game
through data.

By logging structured events across every simulated turn — resources, corruption seen, corruption caught, agent questions — we can graph game balance over time and spot runaway-leader dynamics or dead strategies. Without event-level tracking, simulation feedback is just prose.

Metrics Tracking — Feb 28 Session

Simulation metrics chart — round phase index, agent questions, total resources, corruption seen and caught over turns
Balance Problem Identified
The game may be too "anti-corruption" by default — the lack of overt bribery and corruption is limiting the strategic depth and tension.
Runaway Leader Risk
There is a potential risk of "runaway leader" scenarios if one player is able to establish a dominant position early on. Careful balancing of the bidding mechanics and award conditions would be important.
Why structured logging matters: By instrumenting the simulation to emit structured events per turn, designers can correlate text feedback with actual game state — and distinguish real balance problems from model noise.
Stage 04 Design Where it begins and ends

Nothing replaces
the designer.

Simulation handles the mechanical work — running rules, generating playthroughs, tracking metrics. But the creative leap — deciding what the game should feel like, what tension is worth preserving, what feedback to act on — that belongs to the designer. The goal of all of this is to put more of your time here.

I'm a game designer who has spent the last several years building computer simulation tools for board game design. I'm optimistic about simulation as a multiplier for designers — and rigorous about where it falls short.

2019

Board Game Designer

Started designing games as a beginner — focused on how do you reliably bring a specific experience to a player? That led to an early obsession with researching mechanics and how they produce dynamics that players actually feel. The MDA framework — Mechanics, Dynamics, Aesthetics — became a key lens: designers work from mechanics inward, players experience from aesthetics outward. Understanding that gap between design intent and player reality is where it all starts.

2020

pyplaytest — Open Source

Published an open source Python module for enforcing LLM-driven iteration on game playability. One of the earliest attempts to use language models to evaluate board game rule sets programmatically.

github.com/dat-boris/playtest-deck-mechanics →

2025

LLM-based Agent Simulation

Built a multi-agent computer simulation framework using LangGraph — where specialized simulated agents take on player roles, run full game sessions, and generate structured rule and balance feedback. Applied to The Beautiful Bid, a board game about FIFA corruption.

Each agent follows a branching state machine — game master, bidders, investigator — stepping through turns with LangGraph tracing every decision and state transition in real time.