Inspiration
Poker is a game of incomplete information, where success depends on balancing probability, risk, position, and human behavior. For the TAMU Datathon Poker Bot Challenge, we wanted to create an agent that could do more than follow a fixed chart. Our goal was to build a fast, adaptive player capable of estimating its equity, recognizing opponent tendencies, and changing its strategy over the course of a match.
The challenge uses heads-up Short Deck 5-Card Pot-Limit Omaha. Players receive five private cards and must construct their final hand using exactly two hole cards and three community cards. Short Deck also changes the standard poker hierarchy: flushes beat full houses, while three of a kind beats a straight. These rules made traditional Texas Hold’em strategies insufficient and required us to build an evaluation system specifically around this format.
What it does
Heads Up DT26—also known as Gambling Addict v.2—is an adaptive Python poker agent that combines a trained preflop model, postflop equity simulation, opponent modeling, and risk-aware betting logic.
For each decision, the bot evaluates:
-The estimated strength of its hand -Its probability of winning at showdown -The price of calling relative to the pot -The current betting street -Its position at the table -The opponent’s recent aggression -The opponent’s response to previous raises -The size and frequency of opposing bets -The legal half-pot and pot-sized raises available It then chooses among folding, checking or calling, raising half-pot, and raising pot. These are the only four actions supported by the tournament engine, and all decisions must come from the current observation’s legal-action list.
Instead of playing against an assumed “average” opponent throughout the entire match, the bot maintains a lightweight behavioral profile. It records actions by street, distinguishes between half-pot and pot-sized raises, tracks reactions to our aggression, and uses showdown information when available. This allows it to gradually adjust how tightly it calls and how aggressively it pursues value.
How we built it
We built the bot as a FastAPI web service in Python using the tournament’s starter infrastructure. The referee sends an observation to the bot, and the bot responds with a legal action. Each observation includes the private cards, public board, pot, outstanding call amount, stacks, position, betting history, and available raises.
Our strategy has four primary layers.
Trained preflop hand evaluation
Rather than assigning hand strength through a small set of hard-coded categories, we extract a feature vector from the bot’s five starting cards. These features include:
-Rank multiplicities and pocket pairs -Trips and larger rank groups -High-card concentration -Suited and double-suited structures -Connected ranks and gaps -Ace-low Short Deck connectivity -Potential five-card runs -Overall rank spread We then apply coefficients produced through an offline ridge-regression fitting process against random five-card hands. This gives the bot a fast, calibrated preflop-strength estimate without requiring expensive simulations before every flop.
The resulting evaluator understands that a coordinated, suited hand can have more potential than five individually high but disconnected cards. It also keeps every prediction within controlled bounds to prevent extreme estimates from dominating the strategy.
Deterministic Monte Carlo equity estimation
After the flop, the bot samples plausible opponent hands and missing board cards from the unseen deck. Each simulated showdown is evaluated using the tournament’s native Omaha evaluator, ensuring the bot follows the exact two-hole-card and three-board-card construction rule.
The simulations are deterministic for a given game state. This makes decisions reproducible and prevents random fluctuations from causing the bot to take inconsistent actions in identical situations. The number of trials is also bounded and adjusted by street, allowing the bot to spend more effort when later-street decisions carry more information and higher stakes.
Pot-odds and street-aware decisions
The bot calculates the cost of continuing as:
pot odds = amount to call / (current pot + amount to call)
It compares that price against its estimated equity before calling a bet. Large raises therefore require materially stronger hands, while inexpensive calls can be defended more widely.
Its raising thresholds also change by street. On later streets, where less uncertainty remains, the bot is willing to make larger value bets with high-equity holdings. In more marginal situations, it can use half-pot bets to extract value, deny an opponent’s equity, or conserve chips. The strategy reserves pot-sized raises for its strongest opportunities rather than treating every advantage identically.
Online opponent adaptation
Throughout each half, the bot records behavioral statistics such as:
-Overall and street-specific aggression -Half-pot versus pot-sized raise frequency -Attacks following passive actions -How often the opponent folds after we raise -Showdown frequency -Responses to pressure on each street These observations are used to estimate how exploitable the opponent may be. Against a passive player, the bot can give unusual aggression more credit. Against an opponent who raises excessively, it can widen its continuing range and punish overly loose betting. If an opponent frequently folds to raises, the bot gains carefully gated opportunities for additional aggression.
The adaptation remains intentionally conservative so that a small sample of unusual hands does not cause the strategy to overreact.
Challenges we ran into
Solving an unfamiliar poker format
Short Deck Omaha produces far more complex hand interactions than standard Hold’em. The deck contains only 36 cards, each player holds five private cards, and every showdown considers up to 100 valid two-plus-three card combinations. A board that appears extremely strong may not actually connect with the player’s hole cards under the Omaha construction rule.
We had to ensure that every simulation and heuristic respected the tournament’s evaluator rather than accidentally applying Texas Hold’em assumptions.
Making decisions in milliseconds
Each bot receives only eight seconds of total thinking time for a 1,000-hand half, with an absolute limit of one second per request. Since a bot commonly makes multiple decisions per hand, this leaves only about two to four milliseconds for an average action.
That limitation shaped the architecture of our strategy. We used a fitted model for inexpensive preflop evaluation, bounded simulation after the flop, compact in-memory statistics, and deterministic sampling. This gave us a practical balance between strategic depth and tournament reliability.
Controlling variance
Pot-limit betting causes pots to grow rapidly. With 80-chip starting stacks, a few pot-sized raises can put both players all-in by the flop. An agent that overestimates a small edge can therefore lose an entire stack.
We addressed this with separate thresholds for calling, half-pot raising, and pot-sized raising. The bot is willing to defend close situations when the price is favorable, but it demands more equity before committing additional chips through aggression.
Reliability under tournament conditions
Five errors in a single half result in a forfeit, and a forfeit means losing the match regardless of chip performance. As a result, correctness was just as important as strategy.
We created regression tests that send decisions through the same HTTP endpoints used by the judge. The suite verifies legal actions across hundreds of hands, both seats, both halves, aggressive opponents, and large-bet or all-in situations. It also checks that:
-Preflop strength remains within valid bounds -Premium hands score above weaker structures -Equity estimates are deterministic -Simulation counts remain bounded -The bot checks when raising is unavailable -Pot odds rise correctly with call cost -Opponent actions are not counted twice -Memory resets between halves -The bot survives an opponent that raises whenever possible
Accomplishments that we’re proud of
We are especially proud that our final agent combines several approaches without exceeding the challenge’s strict runtime limits:
-A preflop model fitted offline from simulated hand data -Short Deck Omaha-aware hand evaluation -Bounded, deterministic postflop simulation -Pot-odds-based calling logic -Separate value thresholds for half-pot and pot-sized raises -Street-specific opponent modeling -Online adaptation to betting and folding tendencies -Reproducible decisions for debugging and comparison -Defensive handling of legal-action restrictions -An automated regression suite covering realistic match behavior The result is not just a collection of poker rules. It is a compact decision-making system that transforms cards, betting context, simulated outcomes, and observed opponent behavior into a legal action within milliseconds.
What we learned
This project showed us that building an autonomous game-playing agent requires much more than maximizing raw hand strength. Strong play comes from combining several imperfect signals:
-Equity describes how often a hand may win -Pot odds describe whether continuing is profitable -Position changes the value of information -Bet size communicates pressure and risk -Opponent history changes how actions should be interpreted -Runtime and reliability determine whether the strategy can function at all We also learned the importance of reproducibility. Deterministic simulations and fixed-seed tests allowed us to compare changes against identical situations instead of mistaking random card variance for strategic improvement.
Most importantly, we learned that robustness often beats unnecessary complexity. The tournament explicitly rewards bots that consistently return fast, legal actions, since repeated exceptions, invalid responses, or timeouts can forfeit an otherwise successful match
