The only six-handed
poker engine
you can actually get.
Every commercial solver is a two-player tool. Pluribus, the only published six-handed breakthrough, was never released. NoRegrets plays two to six players from one trained strategy, re-solves each hand live against the range every opponent has represented, and you can read all of it.
Written in Rust over fourteen months by Conor Armstrong, against the published record of Pluribus, the first bot to beat professionals at six-handed poker. Every claim below is a measurement, and every measurement can be reproduced from the repository.
What got better, and by how much
Exploitability is what a best-responding opponent could win against you. It is the only honest scoreboard for a poker AI, and almost nobody publishes it for six-handed play. This is ours, in the pots that matter most: three players or more.
Lower is better. Each point is pooled over eight paired seeds, twenty thousand hands each.
Built for the game people actually play
Almost every published poker AI plays one opponent. Money games have five. Three-handed pots are where a two-player bot quietly falls apart, and they are the only pots NoRegrets was tuned to win.
The strategy is trained by self-play with Monte Carlo counterfactual regret minimisation: the bot plays itself billions of times, and after every hand it asks what it should have done instead. Regret it can never recover from is pruned away, which is where the name comes from. At the table it stops trusting that strategy blindly and solves the hand in front of it.
- Table size
- Two to six players, one blueprint for every seat
- Game
- No-limit Texas hold'em, 50/100 blinds, any stack depth
- Training
- External-sampling linear MCCFR with negative-regret pruning
- Card model
- Equity-distribution clustering under earth mover’s distance
- At the table
- Depth-limited subgame resolving against tracked opponent ranges
- Language
- Rust, no runtime dependencies, 198 tests
- Hardware
- Trains on 16 cores; plays on one
What you are licensed to build
The licence permits research, benchmarking, teaching, strategy analysis, and incorporation into your own software.
It prohibits exactly two things, and they survive every other clause: playing for money on any platform, and taking an undisclosed advantage over a human who has not consented to play software. Everything below sits inside what is allowed.
Study and training tools
Strategy analysis and incorporation into your own product. A trainer can already show a student the two-player answer; almost none can show them a three-way pot, because the solver underneath is a heads-up solver. This one is not. The blueprint covers every seat and the resolver runs a real multiway subgame at the table, in milliseconds rather than minutes.
Integrity and detection teams
Benchmarking against a reference strategy. Collusion detection in the published literature needs two things that are hard to get for six-handed cash: a reference strategy for the game, and value functions over its histories. This engine has both, and the detector built on them is the strongest of the commercial verticals precisely because a detection oracle does not have to be a strong player, only a consistent and multiway-capable one.
Labs and reproducible baselines
Research and teaching. Pluribus was never released: what exists is a paper, a methods supplement and ten thousand logged hands. This is an independent implementation of that architecture that you can read, train, change and cite, with fifty-one gated experiments written up including the ones that failed.
How it actually integrates
A Rust crate and a single static binary. No runtime, no daemon, no Python. The blueprint is a file you load once and query per decision; search runs on one core, so an ordinary server hosts several tables at a time.
There is no REST API in the box, and it would be dishonest to imply otherwise. It is a library with a command line over it. Wrapping it in whatever your stack speaks is a small piece of work, and if you would rather not do it, that is what the day rate is for.
# train a blueprint, or use the one that ships with the licence
pluribus train --iters 500000000 \
--bucket-table buckets.bin --out blueprint.bin
# play it six-handed, re-solving every postflop decision
pluribus play --blueprint blueprint.bin \
--players 6 --search-ms 400
# what a best response wins against you, multiway
pluribus lbr --blueprint blueprint.bin \
--multiway --hands 20000 --seed 1
# and against a table fitted to real human frequencies
pluribus eval --blueprint blueprint.bin \
--table reg,tight,loose,passive,sheriff \
--hands 20000 --search --search-ms 400
# score a session for collusion, pair by pair
pluribus collusion --blueprint blueprint.bin --hands 50000Every command on this page is in the open repository and runs today. The measurement harness is not a demo of the product; it is how the numbers above were produced, and you can re-run any of them yourself.
Three ways to use it
Everything reaches the open repository eventually. Paying moves you to the front of that queue and gets you the trained blueprints, which are never published at all.
The obvious question is why not wait, or use the free one. Answers: the free edition is a year behind and gets further behind every week, it ships no trained artifacts, and reproducing this engine from the papers is what took fourteen months here, most of it spent on the approaches that did not work and are written up so you do not repeat them.
What the numbers on this page were measured on
Every result above came from the current build with the trained blueprints, which is the commercial edition. That deserves saying plainly, because the open edition is a different thing in two specific ways.
It is also worth saying what is not different. The algorithm, the card abstraction, the trainer and the measurement harness are the same code. An open user who spends the compute can reproduce most of these numbers themselves. That is the point of publishing it.
| Open | Commercial | |
|---|---|---|
| Trained blueprints | Train your own | Included |
| Getting to this blueprint | An hour on 16 cores, once you know the recipe | Included, with the recipe |
| Memory that hour needs | About 77 GB | About 41 GB |
| Benchmark against GTO Wizard AI | Not included | Included |
| Probe a 200bb blueprint locally | Not included | Minutes instead of hours |
| Opponent statistics and table reading | Not included | Included |
| Tests | 136 | 198 |
| Commits behind | 118 and growing | Current |
The hour is the last step, and the cheapest one. What it depends on is the recipe: which card abstraction, how many buckets, which bet menu, which pruning rules, how long to weight iterations linearly. Finding that took fifty-one recorded experiments, and the ones that did not work are written up as dead ends precisely so nobody walks down them twice. Run the hour with the wrong recipe and you get a blueprint that is twice as exploitable, which is what the first eight months of this project produced.
The memory figure is the one that bites: halving the trainer's footprint landed after the split, so the open edition needs roughly twice the RAM for the same run. On a 64 GB machine it cannot train the current blueprint at all. The gap in commits was one day old when this was written and widens by a full year of work before any of it reaches the open repository.
Game integrity
For operators and regulators
From $18,000
A scoped pilot on your own hand histories
Collusion detection needs a reference strategy and a value function for the game being played. For six-handed cash that is the hard part, and it is what this engine is.
Measured on a colluding pair planted at a six-handed table: it ranks first of the fifteen pairs, scoring about ten times the best honest pair, and the ranking is stable after 10,000 hands. Honest pairs still score high sometimes, so the pilot is the work of setting a threshold against your own traffic that catches the first without investigating the second.
- ·Per-pair collusion scoring from your hand histories
- ·Bot and assistance scoring: how far each seat sits from solver play
- ·A written method your compliance team can defend
- ·Runs on your infrastructure; hands never leave it
Source licence
For labs, studios and tool builders
$19,500
One payment. Perpetual. No renewals, no seats, no revenue share. Questions are answered by the person who wrote the engine, which is the real limit on how many licensees there can be at once.
The expensive part of this was never the compute. Training the current blueprint costs a few dollars of rented time; you could do it tonight. What it cost was fourteen months of finding out which of fifty-one gated experiments were worth keeping, and most of them were not.
A non-exclusive, perpetual licence to fourteen months of specialist work that would take a competent team a year to reproduce, plus everything added to it from here on.
- ·Full source, ahead of the public repository
- ·Trained blueprints, which are never published
- ·Every future commit for as long as the project runs
- ·Commercial use, no per-seat or revenue terms
- ·Questions answered by the person who wrote it
Architecture and integration work, if you want it, is $3,000 a day, two days minimum, quoted against a scope rather than bundled into the licence.
Open source
For research and for evaluating this
Free
MIT, yours whether you ever pay or not
The complete engine, trainer, solver and measurement harness as it stood 12 months ago. Not a demo and not crippled: it is how you check that anything on this page is true before you talk to anyone.
- ·Full Rust source under the MIT licence
- ·Trainer, live solver and exploitability probes
- ·The complete results log, failures included
- ·Train your own blueprint on your own hardware
NoRegrets is research software for study, benchmarking and building on. Playing a bot for real money breaks the terms of every online poker site, and the licence prohibits it in a clause that does not expire. The full terms are published rather than sent after payment. Tell me what you are building and I will tell you straight away whether this is the right tool for it.
Four stages, in order
Group the hands
Two hole cards on a board give 1,326 possibilities per seat. They are grouped by how their equity is distributed across every river that could still come, so a flush draw and a made pair with the same average strength never share a bucket.
Train the strategy
Self-play traversals in the hundreds of millions. Actions whose regret has gone deeply negative are skipped on most iterations, which spends the compute on lines a good player would actually reach.
Solve the real hand
The blueprint is a starting point, not the answer. Every postflop decision is re-solved from the start of the betting round, using the range each opponent has represented by their actual bets, at their actual sizes.
Measure it honestly
A best-responding probe attacks the strategy and reports what it wins. Nothing is adopted unless it beats the previous version across eight paired seeds. Most experiments fail, and the failures are written down.
The blueprint is where it starts thinking, not where it stops
A stored strategy has to answer every situation with one averaged reply. NoRegrets throws that away on every postflop decision and solves the actual hand: the real board, the real bet sizes, and what each opponent's line says about the cards they hold.
Turning this on lowered the multiway bound on eight seeds out of eight, and turned an opponent that had been beating the raw strategy into one that loses to it.
What each edition gives you
The open edition is this engine as it stood twelve months ago, and it is a real engine: the trainer, the live solver and every probe, under MIT. What the commercial licence adds is the year since, and that year is where the opponent modelling lives.
Concretely, and you can check each one against the public repository: the per-seat and per-pair statistics that read the table, Data Biased Response inside the solver, and bet sizing fitted to 635,017 real postflop bets are all in the commercial build and none of them are in the open one. The trainer also halved its memory there, 41 GB against 77 GB for the same run, which on a 64 GB machine is the difference between training the shipped blueprint and not being able to. The blueprint itself comes trained.
The right-hand column is the outside reference that makes a number mean something. The method behind each row sits under its name, and the full log, including every experiment that failed, ships with the repository.
| Open | Commercial | For scale | |
|---|---|---|---|
| Beating weak opposition A scripted opponent that calls every bet, over 100,000 variance-reduced hands. It measures how hard a fixed, known strategy can be exploited, not a winrate against people: no scripted seat chooses which hands to play. Against seats fitted to the action frequencies of 107,502 real hands the figure is higher still, +283, for the same reason. | Same, once trained | +274bb/100 | A strong human regular makes +2 to +5 against ordinary opposition. |
| What a perfect opponent wins off it What a best-responding opponent wins against the shipped 500M blueprint in three-way and larger pots, pooled over eight paired seeds. Lower is better. Doubling the training to 1B moved this by −60 at t = −1.18, inside the noise, so 500M remains what ships. | Same, once trained | 746mbb/hand | No other six-handed bot publishes this number, including Pluribus. |
| Harder to exploit, solving at the table A perfect opponent - one that knows the strategy exactly and plays the ideal counter - wins 997.6 millibigblinds per hand against the raw blueprint, and 723.5 against the same blueprint re-solving each hand live. Exploitability is the standard measure of how far a poker AI sits from unbeatable, so driving it down is the whole game. Eight paired seeds, t = −3.17, better on seven of eight, interval excludes zero. | Same | 27% harder | Pluribus called depth-limited search the change that made six-handed play possible. |
| Gain from solving, against opponents who choose their hands Opponents fitted to the action frequencies of 107,502 real-money hands, and to the hand strengths people actually bet and call with. Eight paired seeds, t = +2.62. Without search the bot loses to them; with search it is break-even. It does not beat them. | Same | +397mbb/hand | Search wins more AND is harder to exploit at the same time, which is not the usual trade. |
| Gain from thinking longer Sixteen times the search budget per decision, 25ms against 400ms, over 20,000 hands on each of eight paired seeds (t = 4.00). Thinking longer is worth more money: the engine is not wasting the time it is given. | Same | +195mbb/hand | The strongest single result on this page, and the reason faster search is worth building. |
| Trained blueprint About an hour on sixteen cores, and 77 GB of memory in the open edition against 41 GB in the commercial one. | Train your own | Included | On a 64 GB machine the open edition cannot train this blueprint at all. |
| Reads its opponents Per-seat and per-pair action statistics, read live. That people vary their response by WHO is betting is not an assumption here: across 21,606,087 real-money hands, a player fold rate against specific opponents varies 1.6x more than chance, against 1.04x when the opponents are shuffled. Roughly half of players show it clearly. Turning those reads into money is the current work, gated in the open. | No | Yes | Neither Pluribus nor GTO Wizard AI adapts to who is at the table. |
| Exploiting a modelled opponent Restricted Nash Response at p = 0.1 against an opponent model fitted to real players, over eight paired seeds (t = +17.0). It takes the blueprint from clearly losing to that table to roughly break-even. What makes it worth having is the price: the six-handed exploitability bound moves +43.1 at t = +0.5, which is not measurably at all. Note this exploits a model it was trained against, so it measures exploitation of a known opponent, not identification of an unknown one. | Same, once trained | +1029mbb/hand | Twenty-four millibigblinds of winrate per millibigblind of safety given up. At full exploitation the same method loses 17 big blinds a hand. |
| Agreement with Pluribus Replaying the 10,000 hands Pluribus published and counting identical decisions. | Same | 66.8% | Pluribus beat five elite professionals by +4.8 big blinds per 100 hands. |
The two-player benchmarks are not in this table. They are measured, they are losses, and they are further down under the full heads-up measurement record, with the unrounded numbers and the reason a six-handed engine is judged at a two-player game it was not built for.
How to read any of this
Poker results are quoted in big blinds won per 100 hands. The big blind is the forced bet that starts every hand: in a 50 and 100 game, it is 100 chips.
The rate is not capped by the number of hands, because a single hand can win far more than one big blind. Players bet many multiples of the blind, and stacks here are 200 of them. So +5 means winning about one big blind every twenty hands. +274 means winning nearly three big blinds on every single hand, which only happens when the opposition is handing chips over.
Above zero you are winning, below it you are not. Everything else on this page uses millibigblinds per hand, the same measure at finer resolution: 10 millibigblinds per hand is 1 big blind per 100 hands.
Will it beat humans?
It has never played one. The bands below are estimates with their reasoning attached, not measurements, and the one measured row is marked.
The same thing in money
Big blinds are how poker results are quoted, but they are an abstraction. Here is one seat playing 200 hands, roughly an evening online, in a $1/$2 game where the big blind is $2.
| Playing against | Per 100 hands | After 200 hands |
|---|---|---|
| Five players who never fold | +274 bb | +$1,096 |
| Five casual players | +15 to +40 bb | +$60 to +$160 |
| Five seats fitted to real players | +274 bb | −$110 |
| Five strong regulars | -10 to +10 bb | −$40 to +$40 |
| Five of the best players alive | -40 to -10 bb | −$160 to −$40 |
Scale it as you like: the figures are proportional to both the stake and the number of hands. The same seat at $5/$10 for a thousand hands is twenty-five times these numbers, in whichever direction it is going.
Where those bands come from
It has never played one. So the honest answer is an estimate, and here it is with the reasoning attached rather than hidden.
Read these as a seat at a six-handed table: NoRegrets in one chair, five players of that standard in the others, over a sample long enough to mean something.
Five recreational players
+15 to +40bb/100
A home game or a low-stakes online table.
Against a bot that calls every bet it wins 274 big blinds per 100 hands. Real recreational players are far better than that, but they still fold too often to pressure and pay off too often on rivers, and those are exactly the errors a solver-trained strategy collects automatically.
Five solid winning regulars
−10 to +10bb/100
Mid-stakes online players who study.
Roughly a coin flip. Regulars will not find most of the theoretical leak, but they will find some of it, and the bot does not yet adjust to anyone. Its worst-case exploitability is high enough that a patient opponent has room to work.
Five elite professionals
−40 to −10bb/100
The standard Pluribus was tested against.
It should lose. Pluribus beat this group by 4.8 big blinds per 100 hands using roughly 800 times the training compute that has gone into this. Players at that level probe relentlessly, and a strategy that never adapts is a fixed target.
What about a WSOP bracelet winner?
A bracelet is a tournament result, and tournament poker is a different game from six-handed cash: shorter stacks, antes, pay jumps, and a large amount of luck over a single event. Plenty of bracelet winners are not elite six-handed cash players, and plenty of elite cash players have never won one. For anyone who is genuinely world-class at this format, use the elite row above.
Then why not just use Pluribus?
You cannot. It was never released: no binary, no weights, no API. What its authors published is a paper, a supplementary methods document and 10,000 logged hands, and they kept the bot. Everything here was rebuilt from those documents, which is exactly why the agreement figure above is 66.8% and not 100%. The strongest public bot today, GTO Wizard AI, is a subscription you play against rather than code you can run. If you want a six-handed engine you can read, retrain and change, the list is short.
Small print, and it matters. None of the three numbers above is a measurement. No human has played this bot for money or otherwise, and no human trial has been run. They are estimates derived from three things that were measured: what it wins against scripted opponents, how often it agrees with Pluribus across the 10,000 hands Pluribus published, and its worst-case exploitability against a perfect adversary. Each of those is an imperfect guide to human play, and the ranges are wide because the uncertainty is real. They could be wrong in either direction. The only way to settle it is to run a proper trial with paid players and variance-reduced scoring, which is on the roadmap and has not happened yet. If a vendor gives you a single confident number for this, ask them which humans, how many hands, and who scored it.
The shortest list in poker AI
Strong six-handed poker AI exists. Obtaining one does not.
Pluribus was never released: what its authors published is a paper, a methods supplement and 10,000 logged hands, and they kept the bot. GTO Wizard AI is a subscription you play against, heads-up, with no source and no artifacts. The strong open implementations are two-player. If you want a six-handed engine you can read, retrain, change and ship inside your own product, the field is very nearly empty.
| System | Table size | What you can obtain |
|---|---|---|
| Pluribus | Six-handed | Nothing. A paper, and hand logs. |
| GTO Wizard AI | Heads-up | A subscription to play against. |
| DecisionHoldem | Heads-up | Source. |
| Slumbot | Heads-up | An API to play against. |
| NoRegrets | Two to six | Source, trained blueprints, every future commit. |
The same holds for measurement. A search of the published work turns up no six-handed exploitability bound from anyone: Pluribus never reported one, and the heads-up field reports its own. The multiway numbers on this page appear to be the only ones of their kind, which is why they are quoted with their method attached rather than as a headline.
This took fourteen months
Poker AI is not hard because the algorithm is secret. Counterfactual regret minimisation has been published for twenty years. It is hard because the distance between the paper and a bot that holds up in a three-way pot is thousands of small decisions, and almost all of them are wrong the first time.
Seventeen of those wrong turns are written up in full, with the numbers that killed them, so that nobody has to walk down them again. That log is the part of this project that took the longest and the part that is hardest to buy.
- 442
- days of development
- 18,917
- lines of Rust
- 155
- tests, all passing
- 54
- recorded experiments
- 17
- dead ends, written up
- 8
- seeds behind every result
Nothing is adopted on a hunch. A change has to beat the version before it across eight paired seeds, on both the multiway and the heads-up probe, or it goes in the log as a failure and the code is reverted.
Scope, and fit
This was built for three-to-six-handed play, which is the case every commercial solver avoids and the one every real cash game deals.
Two-player poker is largely settled, and the engines that settled it are heads-up specialists. The hard, unsolved problem is what happens when four more people are in the hand: the tree explodes, equilibrium stops being a single answer, and the two-player assumptions quietly stop holding. That is the problem this engine exists for, and it is where you should judge it.
Here is the rest of the truth about it, because you will find it in the first week anyway and it is cheaper for both of us if you find it now.
Multiway exploitability is still four figures.
A best-responding opponent takes about 746 millibigblinds per hand off the shipped strategy in three-way pots, the same figure as the results table above. That is far better than where it started and nowhere near solved. The next run is a single rented job at roughly two hundred times this machine's compute.
Against opponents who choose their hands well, it is break-even, not a winner.
The clearest measurement here. Facing five seats fitted to real human betting frequencies AND to the hand strengths people actually bet and call with, the blueprint on its own is a losing player. Solving each hand at the table closes that gap and makes it roughly break-even, which is what the +397 above is measuring. It does not open a lead. Numbers on this page above +200 bb/100 are against opponents that never fold or that pick their hands at random, and those are not people. Giving it sixteen times longer to think closes part of the gap and does not close all of it.
Its opponents in testing are scripted, not people.
Every number on this page above the benchmarks was measured against seats that follow fixed rules. Four of them are now fitted to the action frequencies of 107,502 real-money hands, and the resulting table goes multiway on 38% of flop decisions where real six-handed play goes 36%. That fixes how often those seats bet and fold. It does not give them hand selection: they fold at human rates, but not with the hands a human would fold. Numbers against them measure how exploitable a fixed strategy is, and are not a projection of a winrate against people.
It does not adapt to the table.
It plays a professional and a novice exactly the same way. Neither did Pluribus, and neither does the strongest public bot today. Reading opponents and safely exploiting them is the next thing being built, and it is the reason the search stack had to be right first.
It is research software, not a product.
A command line, a terminal table, and a results log. No interface, no hosting, no support contract beyond the author answering your questions.
All five are tracked in the open roadmap, with the measurement that will decide when each one is fixed. Fifty-one of these experiments are written up in the open repository, including the ones that failed and the two occasions a result was withdrawn after a control was run properly.
Show the full heads-up measurement record, and why it is not the target
Two-player poker is where the public benchmarks are, and it is the game this engine is worst at, so here it is against them, in full and with the numbers unrounded. Every other bot on this chart is a heads-up specialist built for nothing else. The card abstraction they are all measured through is the same one that produces the six-handed results above, which is the case for reading this as a difference of target rather than of quality.
Do not take the numbers on trust
Every figure on this page is one you can regenerate on your own hardware, from the free repository, without speaking to anyone.
That is the point of publishing the engine rather than only the results. If a number here does not reproduce, that is worth more to me than a sale, so tell me.
git clone https://github.com/conorarmstrong/noregrets.git && cd noregrets
cargo build --release
# precompute the card buckets once (about 3 minutes on 16 cores)
./target/release/pluribus bucket-table --out buckets.bin
# train the blueprint this page quotes (about an hour on 16 cores)
./target/release/pluribus train --iters 500000000 --train-seed 0 --bucket-table buckets.bin --out blueprint.bin
# measure it the way the results table does
./target/release/pluribus lbr --blueprint blueprint.bin --multiway --hands 20000 --seed 1The last command should print a multiway bound near +746 millibigblinds per hand. Run it for seeds 1 through 8 and the mean is the figure in the results table. `BASELINES.md` in the repository carries the command, the date and the caveats for every other number, including the ones that failed.
One caveat that matters: that training run needs roughly 77 GB of memory in the open edition. The change that halved the trainer's footprint is in the commercial build, which needs about 41 GB for the same run. On a 64 GB machine the open edition cannot complete it, and you would train a smaller blueprint instead.
Request access
Say what you are working on. The reply comes from Conor Armstrong, who wrote all 18,917 lines of it, usually the same day, with a straight answer about whether this is the right tool for what you are doing. Sometimes that answer is no.
That is also the honest limit on how many licences exist. Support is one person answering email, so it is sold to people building something specific, not to everyone who asks.
The form is the only way in, and it reaches the same person either way.