Pluribus Poker AI: How It Works

Pluribus is a poker AI built by Noam Brown and Tuomas Sandholm at Carnegie Mellon University and Facebook AI Research (now Meta AI). Published in Science in 2019 as "Superhuman AI for multiplayer poker," it was the first AI to beat elite professionals at six-player no-limit Texas hold'em. This page explains how the Pluribus poker bot works, what the experiments showed, and what was never released.

What Pluribus is

Pluribus is a program that plays six-player no-limit Texas hold'em. Earlier poker AI milestones, such as Libratus in 2017, were heads-up: one opponent, two players in total. Pluribus took on the harder setting where five opponents act around the table. Most real poker is played this way.

The system was described in a 2019 Science paper by Brown and Sandholm (DOI 10.1126/science.aay2400). People also call it Facebook Pluribus, Meta Pluribus, the Carnegie Mellon Pluribus, or just the Pluribus AI. They all mean the same system.

Pluribus is not a neural network that reads the table and outputs an action. It combines two parts. An offline strategy table, called the blueprint, covers the whole game coarsely. A real-time search then refines the decision once a hand reaches the later streets. Both parts are built on counterfactual regret minimization. If that term is new, start with our CFR explainer.

The experiments: how Pluribus was tested

The paper reports two formats. In both, Pluribus played against professionals and was measured with variance-reduction methods because poker results are noisy.

• Five pros and one Pluribus. 10,000 hands over 12 days. The human players were paid for taking part and ranked by their results.
• One pro and five copies of Pluribus. Darren Elias and Chris Ferguson each played 5,000 hands against five Pluribus copies.

Pluribus came out ahead in both formats. In the five-humans format the paper reports about 48 mbb/game, roughly 5 big blinds per 100 hands, with statistical significance. The authors used AIVAT, an estimator that subtracts card luck, to reduce the variance of that number.

A caveat worth keeping in mind: the 2019 results cover about 20,000 hands in total. That was enough for the paper to claim a significant win, but it is a small sample by the standards of poker measurement.

The blueprint: Monte Carlo CFR

Before any game, Pluribus computes a blueprint strategy by playing against itself. The algorithm is Monte Carlo counterfactual regret minimization (MCCFR). It uses external sampling: each iteration explores every action of the player being updated, and samples one action for chance and for every other player.

Two refinements matter. Linear CFR weights later iterations more heavily than early ones, which speeds convergence. Negative-regret pruning skips actions that look bad so the computer spends time on promising lines. See the CFR page for the family of algorithms and their papers.

The paper reports that the blueprint took 8 days on a 64-core server, about 12,400 CPU core hours, and used under 512 GB of RAM. At play time Pluribus ran on two CPUs and under 128 GB of RAM. No GPUs were involved.

Abstraction: shrinking poker to fit

No-limit hold'em has far too many situations to store one by one. Pluribus shrinks the game in two ways.

• Card abstraction. Similar hands are put in the same bucket and share one strategy. The earliest street keeps hands separate. Later streets group them.
• Action abstraction. Instead of any bet size, the blueprint uses a short menu of sizes. When an opponent bets an amount that is not on the menu, the bot maps it to a nearby size or handles it with search.

The exact bet menus were not published, which is one reason a faithful reproduction has to rebuild and test its own. We cover that on the open-source Pluribus page.

Real-time search with four continuation strategies

The blueprint is coarse, so on later streets Pluribus searches. It starts from the current state, builds a subgame, and runs a depth-limited CFR until it hits leaf nodes. Solving to the end of the hand would be too slow with five opponents.

The trick is what happens at a leaf. Each player picks one of four continuation strategies to play for the rest of the hand: the blueprint, and three versions of it biased toward folding, calling, and raising. Because each opponent can choose among them, the search cannot assume the others play a single fixed way. That makes the result harder to exploit than a plain depth limit would.

The search is also where Pluribus handles hands where the opponent's earlier actions leave it unsure what they hold. It keeps a probability for each hand the opponent could have and updates it as they act. The same idea underlies how modern bots reason, and the history of poker AI shows how it grew out of Libratus and DeepStack.

Why it mattered: multiplayer, no equilibrium guarantee

In two-player zero-sum games, CFR has a guarantee: the average strategy converges to a Nash equilibrium, which cannot be beaten in expectation. With three or more players that guarantee disappears. A Nash equilibrium can still exist, but playing one does not protect you, because other players can effectively team up against you without meaning to.

Pluribus did not solve that theoretical problem. What it showed is that self-play with CFR, plus search, works well in practice anyway. That shifted the question from "can this be proved" to "how strong can it get," and it is the reason six-player AI work builds on the same toolkit. For a practical view of the six-seat game, see six-max poker AI.

What was never released

Pluribus's source code and its trained strategy were never released. The paper describes the method in enough detail to guide a reproduction, but not the exact bet sizes, bucket definitions, or training schedule. The trained blueprint is not available to download, so nobody outside the authors can run the actual Pluribus.

We built an open reproduction to fill that gap. SHARINGAN-2 is a six-player blueprint trained from scratch in Rust, played with real-time turn and river search, and published with weights and code. It is a reproduction, not Pluribus itself, and it has not played professional humans. Details and honest results are on the open-source Pluribus page. You can play against it in a browser, or read the docs.

FAQ

Who made Pluribus?

Noam Brown and Tuomas Sandholm built it at Carnegie Mellon University and Facebook AI Research, now Meta AI. It was published in Science in July 2019.

Did Pluribus beat professional poker players?

Yes. In the paper it beat professionals in two formats: five pros against one Pluribus over 10,000 hands, and one pro (Darren Elias or Chris Ferguson) against five copies of Pluribus over 5,000 hands each.

How does Pluribus work?

It computes an offline blueprint strategy with Monte Carlo CFR, then refines decisions in real time with depth-limited search. At the search leaves, each player chooses among four continuation strategies.

How much computing power did Pluribus need?

The blueprint took 8 days on a 64-core server, about 12,400 CPU core hours, with under 512 GB of RAM. During play it used two CPUs and under 128 GB of RAM.

Is Pluribus open source?

No. Its code and trained strategy were never released. Open reproductions exist, including SHARINGAN-2, which ships code and weights but is not the original system.