Poker AI: History, Open Source, and Where to Test

Libratus beat four heads-up specialists across 120,000 hands in 2017. Pluribus beat elite pros at six-player No-Limit Hold'em in 2019. Poker AI you can run is a smaller thing: a legal action, a card engine, and a table that still keeps score after the paper is done.

Key Takeaways

• Libratus and Pluribus are published results, not packages you can install.
• Slumbot is a public heads-up bot. The stack resets every hand, so it is a benchmark, not a season.
• PokerKit, OpenSpiel, RLCard, and the public Slumbot solver code do different jobs.
• An LLM can be the policy only if your code rejects illegal actions and has a fallback.
• Open Poker is free 6-max No-Limit Hold'em, virtual chips only, in 14-day seasons.

What did Libratus, Pluribus, and Slumbot actually do?

Search for poker AI and three names show up together. They were three different experiments.

Libratus is the Carnegie Mellon system from Noam Brown and Tuomas Sandholm. In January 2017 it played the Brains vs. AI match at Rivers Casino: 120,000 hands of heads-up No-Limit Texas Hold'em, 20 days, against Jason Les, Dong Kim, Daniel McAulay, and Jimmy Chou. The Science paper reports a win of 147 milli-big-blinds per game, with a p value of 0.0002 if the hands are treated as independent and identically distributed. CMU's news post reported a collective chip lead of $1,766,250. The paper's method has three parts: a blueprint strategy on an abstracted game, nested subgame solving during the hand, and a self-improver that patched holes the humans had found. (Science, CMU, 31 Jan 2017)

Pluribus is the 2019 six-player system from the same pair, this time with Facebook AI. It trained by self-play, with no human data in the strategy, and it does not adapt to the opponents in front of it. The Science paper reports two incentivized tests, both scored after the AIVAT variance reduction. Against five pros at a time, over 10,000 hands, Pluribus won 48 milli-big-blinds per game (standard error 25, p = 0.028). Chris Ferguson and Darren Elias each played 5,000 hands against five copies of Pluribus. Across those 10,000 hands the win was 32 milli-big-blinds per game (standard error 15, p = 0.014). The blueprint took 8 days on a 64-core server, 12,400 core hours, under 512 GB. Live play used two Intel Haswell E5-2695 v3 CPUs and under 128 GB. (Science, published 30 Aug 2019)

There is no official Pluribus package. The builder's reading of the paper is Pluribus poker bot explained.

Slumbot is the public bot at slumbot.com. The site says you play heads-up No-Limit Hold'em, blinds 50 and 100, with stacks of 200 big blinds (20,000 chips), and the stack resets after every hand. It also says the 2018 version won the Annual Computer Poker Competition. Researchers can send HTTPS POST requests with a JSON body to slumbot.com, including /slumbot/api/new_hand and /slumbot/api/act. Open Poker vs Slumbot is the practical comparison: one stable heads-up opponent versus a 6-max field.

The reset is the part builders skip. Slumbot will not tell you whether a bot can protect a stack for 14 days, because the stack does not survive the hand. Use it when the question is heads-up decision quality. Use something else when the question is a season.

Eric Jackson's public solver code is a separate artifact. slumbot2019 is MIT-licensed CFR and MCCFR code for Hold'em-like games, with card and betting abstractions and head-to-head evaluation. The site links that repository for issues. Do not treat the repo as a drop-in copy of the bot on the website.

How does poker AI pick an action?

A chess engine scores a board both players can see. Poker cannot. The value of a bet depends on how often you make that bet with other hands, because an opponent who can tell "big bet means the nuts" just folds.

The research systems attack that with the same rough shape.

They shrink the game. Similar hands share a bucket. Only a few bet sizes exist in the abstraction. Libratus used Monte Carlo counterfactual regret minimization on that smaller game for its blueprint. CFR, introduced by Zinkevich, Johanson, Bowling, and Piccione at NeurIPS 2007 and cited in the Libratus paper, keeps a regret for actions that would have done better, then plays higher-regret actions more often. Over many iterations the average strategy improves. In two-player zero-sum games, that average converges toward a Nash equilibrium. Pluribus uses a Monte Carlo CFR variant too, and the paper is explicit that the equilibrium guarantee does not come along for the ride once a third player sits down.

They search the hand they are actually in. The blueprint is coarse. Libratus plays the blueprint early, then solves a finer subgame and tries to keep the opponent from doing better than they would have against the blueprint. Pluribus plays the blueprint on the first betting round, then searches. At the leaves of that search, the paper says each player may pick among four continuation strategies: the blueprint, plus blueprint versions biased toward folding, calling, or raising. DeepStack, which the same section cites as the prior two-player approach, priced leaves from beliefs instead. Libratus searched to the end of the hand. Six players made both of those too expensive, which is why the continuation strategies exist.

Then they stop. Pluribus does not rewrite its strategy because you bluffed the last ten hands. A builder who hears "poker AI" and pictures an opponent model is picturing a different program.

You do not need that stack to play a legal hand. A first bot needs the actions the table offered, a hand-strength or equity estimate, a hard fold for trash, and some randomness when the spot is close. Deterministic "big bet equals value" gets read. The engineering version of that path, with code, is the 2026 guide to building an AI poker bot.

For a 6-max bot rather than a paper, skip the solver until a simple policy has played real opponents. A CFR port that never sits down has taught you nothing about your parser.

Which open-source poker AI should you run?

Pick the repository for the job. Cloning the famous one is how people lose a month.

Install PokerKit when the bot has to deal, bet, and show down a hand. It is pure Python, from the Universal, Open, Free, and Transparent Computer Poker Research Group, and the README reports 99% coverage from type checks, doctests, and unit tests. It is a rules library. It will not choose a bluff for you.

Use OpenSpiel when you want to read a CFR implementation on a game small enough to finish. The project describes itself as environments and algorithms for reinforcement learning and search in games, with a C++ core and a Python API. One of its tutorials implements CFR and REINFORCE on Kuhn poker, Leduc poker, and Goofspiel. The paper is the long version. It is a poor place to learn 6-max sizing, and a good place to see why "regret" is a number and not a mood.

Use RLCard when the experiment is the learning algorithm. DATA Lab at Rice and Texas A&M built it as a card-game RL toolkit. No-Limit Hold'em is included, and the README says that action space is abstracted. Fine for a paper. Awkward as the rules engine inside a live client. The RLCard paper states the aim.

Leave any repo that markets itself as Pluribus. The artifact is the Science paper.

Can an LLM be the poker AI?

It can be the function that maps a visible state to one action. It cannot be the thing that decides whether that action is legal.

Send the hole cards, the board, the pot, the stacks, and the actions the table actually offered. Demand one action back. Parse it. If the action is not in that list, or the raise size is outside the allowed range, throw it away. If the call is late or the text is not parseable, send a fallback you already trust: check when checking is free, otherwise fold. Log the rejection. A model that starts the reply with a sentence will eventually hit a parser that expected a bare action.

That gets you a bot that can talk through a messy multiway turn. It also gets you a bot that can miss the clock, invent a size, or bet the pot every time. Those three are the measurements that matter. Working code for an Open Poker client is in Use Claude or GPT-4 as your poker bot's brain.

Do not make the model the only policy. Preflop trash does not need a network round trip. A heuristic that folds it, and calls the model only when the spot is actually strange, is easier to debug than a prompt that handles everything.

Where do you test a poker AI?

Three questions get mashed into "where can I play poker AI."

Local rules code answers whether the evaluator and the parser are wrong. Slumbot answers how a heads-up policy looks against one strong bot whose stack resets. A season answers whether the bot still has chips after two weeks of opponents it did not write.

Open Poker is the third test. Gameplay is free. The game is 6-max No-Limit Texas Hold'em. Chips are virtual, and real money is not in the pot. A season lasts 14 days. Every bot starts with 5,000 chips. Blinds are 10/20. Optional Pro is $5 per season for extra tooling, and you can compete without buying it. Any language that can hold a WebSocket and parse JSON can take a seat. There is no manual-play UI. The seat is for an agent.

The rules are in the game rules and season docs. The connection steps are the quickstart.

Connect a boring bot before you connect a clever one. A heuristic that folds trash and answers in time will teach you more in one season than a solver that never joins a table. When you want the full build sequence, use the 2026 guide. When you want the first socket open, create the bot and point it at the quickstart.

FAQ

Did Pluribus solve poker?

No. The 2019 Science paper reports a superhuman result in one six-player No-Limit Hold'em setup: 48 milli-big-blinds per game over 10,000 hands against five pros at a time, and 32 milli-big-blinds per game over the 10,000 hands Ferguson and Elias played against five copies of the bot. Both figures are after AIVAT. That is not a solution for every stack depth, blind structure, rake, or table size.

Is Libratus the same result as Pluribus?

No. Libratus played heads-up in 2017 and won by 147 milli-big-blinds per game over 120,000 hands. Pluribus played six-handed in 2019. The Pluribus paper says a Nash equilibrium's "you cannot lose in expectation" property is a two-player zero-sum fact, and that it does not transfer cleanly to three or more players.

Can I download Pluribus or Libratus?

No official public bot shipped with those papers. Read the papers for the method. Run PokerKit, OpenSpiel, RLCard, or slumbot2019 if you want files. The practical walkthrough of Pluribus is Pluribus poker bot explained.

Is Slumbot a 6-max season?

No. The site is heads-up, blinds 50/100, 20,000-chip stacks, and the stack resets after each hand. Use it to benchmark a heads-up policy. The side-by-side with a seasonal 6-max arena is Open Poker vs Slumbot.

Will an LLM beat a tuned heuristic?

Measure it. An LLM can be the policy if every action is checked and a fallback exists when the model is late. A tuned heuristic is usually easier to keep inside the action clock. The working setup is Use Claude or GPT-4 as your poker bot's brain.