Inspiration
Poker is a game where math, randomness, and people meet to create a truly engaging experience. A good hand may be weak against one player but excellent against another. We thought it would be interesting to try to create an agent that could deal with such situations using probability together with knowledge about its opponent. This is why we came up with PokerPulse – an agent making smart choices while dealing with different styles of play within limited computational resources.
What it does
PokerPulse autonomously plays heads-up Short Deck Omaha. It evaluates its cards, considers possible outcomes, observes betting behavior, and chooses whether to fold, call, check, or raise. As a match progresses, it tracks tendencies such as aggression and willingness to fold, using those observations to adjust its decisions. Its goal is to find profitable opportunities while managing uncertainty and responding quickly enough to stay within the tournament’s limits.
How we built it
We built PokerPulse in Python, using Deep Research to help develop, review, and iterate on the implementation. The bot combines fast card evaluations, simulations of possible outcomes, and lightweight opponent tracking. We used FastAPI for communication with the tournament judge and Docker to package the application consistently. Throughout development, we compared different approaches through automated tests and full matches, using the results to decide which changes belonged in the final version.
Challenges we ran into
One of our biggest challenges was balancing strategic sophistication with practical performance. More complicated approaches sometimes looked promising during development but consumed too much processing time under tournament conditions. We also found that success against a few opponents could hide weaknesses against other styles. This pushed us to broaden our testing, investigate losses, and distinguish a small positive result from a dependable advantage. Choosing the final version required weighing playing strength, consistency, and reliability together.
Accomplishments that we're proud of
We’re proud of turning the initial concept into a working, reproducible tournament entry. Our selected version earned eight wins and one chop across nine full-length container matches against three competitor bots, while remaining within its operating budget. We also built a testing process that checked game rules, communication, and performance. Having the final code and required model files available through GitHub made the project easier to reproduce and gave us a clear, verifiable submission.
What we learned
We learned how much competitive performance depends on careful evaluation. A promising idea needs to survive different opponents, fresh matches, and the same restrictions it will face in the tournament. We also learned that complexity brings costs: additional modeling can improve some decisions while introducing timing problems or new weaknesses. Most importantly, this project taught us to use AI-assisted development alongside measurable evidence, investigate disappointing results, and make deliberate decisions about what to keep in the final product.
