How poker solvers work: from game trees to GTO

A poker solver looks like a black box that spits out percentages, and that mystery puts a lot of players off using it well. Underneath, it is doing something you can picture clearly: it maps out every way a hand can play out, then searches for the one strategy no opponent can exploit. This article opens the box. You will see what a solver actually computes, the algorithm that gets it there, and the right way to learn from what comes out.

What a solver is and the problem it solves

A solver is software that answers one hard question: in this exact spot, what is the strategy my opponent cannot exploit? Poker is an imperfect-information game, meaning you never see the other player's cards, so "the best play" is not a single move. It is a whole strategy for your entire range of hands, balanced so that no counter-strategy beats it in the long run. That balance point is the Nash equilibrium, and the solver's job is to find it for the spot you hand it. This is the engine behind what GTO poker actually means: GTO is just the name for the equilibrium a solver converges on.

The game tree

Before a solver can search, it has to lay out the spot as a game tree: a branching map of every decision and every card that can come. Four ingredients define it.

• Ranges for both players. Not single hands, but the full set of holdings each player can have here, weighted by how often. After two hole cards there are 1,326 possible combos, which collapse to 169 strategically distinct starting hands, and the betting so far narrows both ranges to a realistic subset.
• The allowed bet sizes. You cannot search infinite bet sizes, so the tree allows a chosen menu, perhaps a 33 percent, 75 percent, and pot-sized bet plus an all-in. Each size is a separate branch. The bet sizing article explains why these specific sizes get chosen.
• The streets. The tree runs from the flop through the turn to the river, with every possible runout card opening new branches.
• The stack and pot. These set the depth of the tree and the price of every decision inside it.

Picture a flop spot: hero can check or pick a bet size, villain can fold, call, or raise to each branch, then a turn card falls and the whole thing repeats, then a river. The tree fans out fast, and every leaf is a showdown or a fold with a known payout.

The core algorithm: counterfactual regret minimisation

A tree this big cannot be solved by brute force, so solvers use counterfactual regret minimisation, usually shortened to CFR. The intuition is friendlier than the name.

CFR plays the whole tree against itself, over and over. On each pass it picks actions according to its current strategy, reaches the showdowns, and tallies the results. Then comes the key step: at every decision point it asks, "how much better would I have done if I had taken a different action here?" That gap is regret. If betting would have earned more than checking did, the bet collects positive regret.

After each iteration, the solver shifts its strategy toward the actions it regrets not taking, in proportion to that regret. Repeat this millions of times and something remarkable happens. The accumulated regrets average out, and the average strategy over all iterations converges toward the Nash equilibrium. Neither range can find an action that beats the other's, because any profitable deviation would have generated regret that already got corrected. The frequencies you see on this site come from an open-source DCFR solver, a discounted variant of CFR; the underlying method traces to peer-reviewed research, Brown and Sandholm, "Solving Imperfect-Information Games via Discounted Regret Minimization" (2018).

CFR never gets told the right answer. It discovers it by repeatedly noticing where it left value on the table and leaning into those actions a little more each time.

What "solved" actually means

A solve almost never returns "always bet". It returns a mixed strategy: bet this hand 70 percent of the time, check it 30, because mixing keeps your range unreadable. Learning to read that output is its own skill, covered in how to read a mixed strategy.

"Solved" does not mean perfect to infinite decimals. It means the solver got close enough that the remaining exploitability is tiny. Exploitability is measured as the expected value an opponent could win by deviating optimally against the strategy, expressed as a fraction of the pot. When that number drops to a fraction of a percent, the spot is treated as game theory optimal. The whole point of the equilibrium is that this number is as small as it can be: it minimises how much anyone can take from you.

Inputs and outputs

The contract is clean. You feed the solver four inputs: the two ranges, the board, the stack and pot, and the bet-size tree. It returns two outputs: per-hand action frequencies, and the expected value of each action for each hand. That EV is what lets you compare a close bet against a close check, and it is grounded in the same pot odds and equity math you already use by hand.

Why solves are slow

The tree is enormous. Two ranges, several bet sizes, three streets, and every runout multiply into an astronomical number of decision points, and CFR has to traverse them millions of times. Two tricks make it tractable. Suit isomorphism recognises that strategically identical boards do not need separate solving: the 22,100 raw flops reduce to roughly 1,755 distinct ones once you stop double-counting suit-equivalent layouts. Abstraction goes further, grouping similar hands and trimming the bet-size menu so the tree fits in memory. Even so, a full solve can take seconds to minutes, which is why this site precomputes spots offline rather than solving live.

The right way to use the output

Here is where most players go wrong: they try to memorise frequencies. Do not. A solver's exact numbers are tied to its precise inputs, and the next real spot will differ. What transfers is the pattern and the reason. Notice that dry boards favour small, frequent bets while wet boards mix more, and ask why a hand bluffs on one card and gives up on the next, often because of blockers. Build that intuition through review, keeping the study not play discipline front of mind. On this site, the analyzer puts a precomputed solve behind a photo of your hand, so you can review a real spot and read its frequencies. It is a study and review tool, never live assistance during online play, which breaks every site's rules.

Bottom line

A poker solver represents a spot as a game tree of ranges, bet sizes, streets, and stacks, then runs counterfactual regret minimisation, iterating millions of times and accumulating regret until the average strategy converges on a Nash equilibrium that minimises exploitability. The output is a mostly mixed strategy with an EV for every action. Suit isomorphism and abstraction make the huge tree solvable, but it stays slow. Study the patterns and reasons, not the exact percentages, and treat the analyzer as review away from the table.