bluffr-1, model card

Bluffr aims for an equilibrium strategy: one that no opponent can beat in the long run, whatever they do. It plays a balanced mix of actions so it has nothing to exploit, which is why every answer comes with probabilities. Asked one spot at a time, as the API asks it, Bluffr has no memory between requests, so its answers are always this strategy. Over a session against one opponent, Bluffr can also read them and bend the mix towards their mistakes (section 5).

1. A smaller game it can solve

No-limit hold'em has far too many situations to solve directly, so Bluffr trains on a compressed copy of it:

• Cards. Before the flop, the 169 distinct starting hands. After it, hands are grouped by how often they beat a random hand (20 groups on the flop and turn, each split nine ways by draws: no flush draw, a flush draw or the nut flush draw, and no straight draw, a gutshot or an open-ended draw; 40 groups on the river). Suited and offsuit hands are different hands before the flop, so 7♥6♥ plays where 7♦2♣ folds.
• Bets. A first bet or raise of ⅓, ½, 1, 1.5 or 2 times the pot, or all-in; re-raises of half the pot, the pot or all-in; four per street. Earlier blueprints (abstraction v2) know ½, 1 or 2 times the pot first and pot re-raises, and still play with exactly those sizes; the API's abstraction_version and bet_sizes say which one is live.
• Situations are told apart by those groups, position, stack-to-pot ratio, who led the last street, and this street's betting. Stack depths from 20 to 200 big blinds are mixed in training.

2. Self-play with regret

Bluffr learns with external-sampling Monte Carlo counterfactual regret minimisation, the family of algorithms behind Libratus and Pluribus. It deals itself hands, and at each decision asks how much better each other action would have done. Actions it regrets not taking get played more next time. Averaged over many hands the strategy settles towards equilibrium. The current blueprint ran 1.27 billion iterations and holds 192 thousand situations. The same trainer is checked on Kuhn poker, where it reaches the known solution.

3. It searches the flop, turn and river

The compressed game blurs hands together, so after the flop is dealt Bluffr stops reading the blueprint and solves the street at decision time:

1. Ranges. Every holding each player could have is weighted by how likely the blueprint makes the betting that got here, with a little noise so a player who left the blueprint keeps their hands.
2. Tree. The street's betting from its first action, with the trained sizes plus every action actually taken this street at its exact size.
3. Solve. Vector-form CFR over every holding at once, with exact showdowns and card removal. The river is solved with CFR+. The turn search is depth-limited: it looks ahead through a simpler river (check, pot, all-in) for every river card, sampling a few per pass, and solves with linear CFR. The flop search is shallower still: after the flop's betting it checks the hand down over a couple of dozen sampled turn and river cards.
4. Play. Bluffr plays the solve's average strategy for its own holding at the spot it is at. Each holding is averaged on its own, so a hand with nothing folds at the end of a raise war instead of calling because the rest of the range would.

4. The answer

Bluffr maps the real betting onto the sizes it knows, takes its mix for the spot, drops actions it plays under 5% of the time, and returns the mix as named options with a sampled choice and a confidence: one minus the mix's entropy, scaled so a pure choice is 1 and an even split is 0.

5. Reads, over a session

An equilibrium loses little to anyone but does not punish mistakes, so against weak players it wins far less than it could. Playing one opponent over many hands, Bluffr counts how often they bet when they could and how often they fold to a bet, before and after the flop, and compares that with how the blueprint plays itself. Against players who bet too much it calls down wider with fair hands; against players who rarely bet it respects their bets; against players who never fold it stops bluffing and bets thinner for value; against players who fold too much it bluffs more. Each change grows with the evidence and is capped. Rates within 0.15 of the blueprint's are left alone, and the change fades in between 0.15 and 0.30: a strong player can differ from Bluffr that much just by playing a different balanced style, and bending against them gives money away. Reads never turn a hand into an all-in the strategy did not already choose.

It also learns from showdowns. Every river bet an opponent shows down counts as value or a bluff, kept apart for small bets and big ones, so a player who bluffs with one size and value bets with another is called down against the first and folded to against the second. Old evidence fades by half a percent a hand, so a player who changes gear is followed within a couple of hundred hands.

Bluffr also reads single spots, each against its own normal rate: c-betting the flop and folding to a c-bet, betting the turn again and folding to a turn bet, betting and folding on the river, 3-betting and folding to a 3-bet. A player who folds too often to turn bets gets barrelled; a player who rarely c-bets but bets the turn is given credit. Exploiting is a risk, so every change is scaled by an exploit weight. It starts small, grows as Bluffr wins from the opponent, and shrinks back to the plain strategy if the hands where Bluffr bent start losing. An opponent who baits Bluffr into bending can only take back a little of what they gave. On the play page, Bluffr names your style as it reads it, and says what it is doing about it.

Tuning

Two dials lean Bluffr away from the trained strategy, from -1 to 1. Aggression turns checks and calls into bets and raises, mostly with strong hands and draws, or the reverse, bluffs first. Looseness turns folds into calls with middling hands and draws, or the reverse, weakest hands first. At 0 nothing changes.

The trained strategy is the strongest against a player you know nothing about: every lean costs 9 to 17 big blinds per 100 hands against Bluffr itself. Against the right player a lean pays. Looseness at +1 nearly doubles Bluffr's win against a maniac (+102 to +198 bb/100), and aggression at -1 adds half against a calling station (+44 to +67). The reads find those exploits by themselves, so the dials are for choosing a style, not for winning more.

How strong it is

Strength is measured in big blinds won per 100 hands, on duplicate deals: every deal is played twice with the seats swapped, so card luck mostly cancels. Run bluffr match --agent bluffr-gto --opponent bluffr-blueprint-gto --deals 400 to repeat this.

These are small samples: real leads, not proof. The share of hands won says little about strength (folding a bad hand is a lost hand and a good decision), so Bluffr never reports it.

Bluffr is judged on one thing: money made over the long run. Against each style it has to win more big blinds per 100 hands (bb/100) than the 95% margin, so the profit is real and not luck. bluffr bench plays Bluffr (blueprint with reads) against fourteen rule-based player styles, 40,000 hands each. It makes money against every one:

Over a longer run the edge holds. bluffr crowd varied every style, plus a player that ignores its cards, into 150 different players, and Bluffr played 20,000 hands against each: 3 million hands in all. It made money against all 150 players: +121 bb/100 overall (± 2), or 3.6 million big blinds. Its smallest edge was +23 bb/100, against the tight-aggressive regulars, and its biggest was +255, against whales.

The styles are caricatures, far weaker than real professionals; beating them shows Bluffr has no gross leaks, not that it beats pros. For scale, Libratus beat top professionals by about 15 bb/100.

Against Slumbot

Slumbot is a strong heads-up research bot that invites other bots to play it through a public API, 200 big blinds deep. It is the closest thing here to a real professional. bluffr slumbot --hands 2000 plays it and reports every hand so far. Hands where both players are all-in before the river are credited at Bluffr's exact equity, which takes out much of the luck of the run-out.

None of these is a verdict yet; telling a small edge from noise against a player this good takes tens of thousands of hands. The reports did point at two real leaks, both fixed: on the turn and river, search averaged its strategy in a way that let hands with nothing call or shove at the end of raise wars, and reads could turn a value bet into an all-in. One lead is still open: facing a bet on the turn, Bluffr raises about 19% of the time to Slumbot's 7%.

Where it is weak

• The compression costs strength: Bluffr treats some different hands alike and only knows a handful of bet sizes before the turn.
• More training no longer helps much: 640 million more iterations changed nothing measurable. The next gain needs a finer compression, trained from scratch; the nine draw groups are that compression, and the published blueprint predates them until the new one finishes training.
• Search assumes both players started from the blueprint's ranges. A very unusual opponent is read through that lens.
• Reads trust a session's averages, so an opponent who changes gear can lead Bluffr the wrong way for a while; the exploit weight limits what that costs.
• Against Slumbot, a strong research bot, the result is still inside the noise after a few thousand hands (see above).
• No strategy here comes with a promise of winning.