A poker solver is not magic, and it is not a guess engine. It is a math tool that asks a very specific question:
If both players know the spot, the board, the stack depth, the allowed bet sizes, and each player’s range, what strategy is hardest to exploit?
That question sounds simple. The answer is not. Even one flop spot can explode into thousands of branches once you allow checks, bets, raises, calls, folds, and several possible bet sizes. A solver is built to handle that complexity by turning poker into a tree, then searching that tree until the strategies stop changing in a meaningful way.
What a solver is actually solving
A solver does not solve “poker” in the absolute sense. It solves a model of a spot.
That model usually includes:
- the positions of the players
- the board cards already out
- the stack sizes
- the pot size
- the ranges for each player
- the bet sizes each player is allowed to use
- sometimes rake, sometimes ICM, sometimes not
If you change any of those inputs, the answer can change. That is why a solver is best understood as a “what if” machine. What if you open this size? What if your opponent defends this range? What if turn and river bets are limited to these sizes?
A solver is only as strong as the spot you give it.
That is also why there is no single “the solution” to a poker hand. There is only the solution to the exact game you defined.
Ranges are the starting point
When players first learn solvers, they often look for one hand at a time: “Should I bet ace queen here?” But a solver does not think in isolated hands. It thinks in ranges.
A range is the set of all hands a player can reasonably have in that spot, with some weight on each one. For example, preflop, the button might arrive on the flop with a wide range, while the big blind arrives with a more defended range. Those two ranges are different before a single flop action happens.
That matters because equity, folds, raises, and future streets all depend on ranges, not on one exact hand.
A solver asks questions like:
- How often can the button bet for value?
- How many bluffs does that size allow?
- Which hands prefer checking because they keep equity well?
- Which hands prefer betting because they gain from fold equity?
You can think of the 13x13 grid as a map of possibility. Pocket pairs, suited hands, offsuit hands, each gets a place. The solver then assigns actions and frequencies to those hands based on the ranges and the board.
The game tree: poker as a set of branches
Once the ranges are set, the solver builds a game tree.
A game tree is just a flowchart of every decision that can happen from the current spot forward. Each node is a decision point. Each branch is an action. Each action leads to another node, and so on, until the hand ends.
For example, on the flop:
- Player A checks
- Player B bets 33% pot
- Player A folds, calls, or raises
- If there is a call, the turn is dealt
- Then the tree continues on the turn
If you allow two bet sizes on the flop, three on the turn, and an all-in option on the river, the tree gets huge very fast. This is why solvers need abstraction. They cannot include every possible bet size in every spot, because the tree would become too large to compute.
So the person building the solve chooses the menu of actions in advance.
That choice matters a lot.
If a 25% pot bet is not in the tree, the solver cannot recommend it. If an overbet is excluded, the solver cannot use it. In practice, solver work is partly poker and partly good modeling.
How the solver finds an equilibrium
The goal of the solver is usually a Nash equilibrium for the model you defined.
An equilibrium means that, given the opponent’s strategy, you cannot improve your own result by changing only your strategy. In a two-player zero-sum game, that is the stable point solvers search for.
How do they get there?
They do it by iteration.
A simplified version looks like this:
- Start with an initial strategy.
- Walk through the tree and compute expected values.
- Find where each action would have done better or worse.
- Update the strategy to reduce those mistakes.
- Repeat millions of times.
Different solvers use different exact algorithms, but the idea is similar. They keep measuring how good each action would have been, then they shift weight toward the better actions and away from the worse ones. Over time, the strategy becomes more stable.
A common family of methods is based on regret minimization, especially CFR, Counterfactual Regret Minimization, and its variants. The name is technical, but the intuition is simple:
If one action keeps proving better than another in a given situation, the solver learns to lean more toward it. If two actions have exactly equal EV in the model, it may mix between them.
That is why solver outputs often show frequencies, not a single move. A hand can check part of the time and bet part of the time because those actions are exactly indifferent in the model, even if the solver only reaches that point approximately.
Why solvers repeat so many times
People often say a solver “runs millions of hands.” What they mean is that it simulates, evaluates, and re-evaluates the spot over and over, across many possible runouts and many iterations of strategy updates.
This repetition is necessary because poker is recursive. A small error now changes the rest of the tree later. If your flop strategy is off, your turn and river branches are off too.
The solver keeps going until the strategy changes very little from one iteration to the next, and the remaining error is small enough to accept.
That does not mean the answer is perfect. It means the answer is good enough for the model and the computing budget.
Exploitability, or how close the answer is
The word you want here is exploitability.
Exploitability measures how much a perfect opponent could gain against your strategy if they knew it and responded perfectly. The lower the exploitability, the closer the strategy is to equilibrium.
In a toy example, if a solved strategy has very low exploitability, that means it is hard to exploit within that model. If exploitability is higher, there is more room for improvement.
But exploitability only means something relative to the spot you modeled.
If the ranges are wrong, the exploitability number may be precise and still misleading. If the available bet sizes are unrealistic, the answer may be mathematically consistent and strategically awkward. If the rake, stack depth, or ICM pressure is missing, the result may be clean and still not match the game you actually play.
So when you read a solver output, do not ask only “Is it exact?” Ask first, “Is this the right model?”
What the frequencies really mean
A solver output often shows things like:
- bet 33%
- check
- call
- raise
- fold
That does not mean the solver believes humans will do that in practice. It means that, inside the model, that action carries that share of the strategy.
Here is a simple example of poker arithmetic.
If the pot is 100 and you bet 50, the pot odds for the caller are 50 to win 200 total. The caller needs 50 / 200 = 25% equity to continue profitably, before considering future streets.
If you are facing that bet, the minimum defense frequency is:
100 / (100 + 50) = 66.7%
That number is not a solver output. It is just poker math. But it helps explain why solvers often mix value hands and bluffs in a way that pressures the opponent’s continuing range.
A solver is constantly balancing those relationships:
- how much fold equity the bet creates
- how much value the value hands gain
- how much equity the bluffs retain
- how often the opponent must defend to avoid being exploited
Why a solver may mix actions
At first, mixing looks strange. Why would the same hand bet sometimes and check sometimes?
Because in many spots, no single action is clearly best. If two actions have exactly the same EV in the model, the equilibrium can split the difference.
That mix serves several purposes:
- it keeps the strategy balanced
- it protects strong hands from becoming too obvious
- it prevents weak hands from overcommitting
- it makes the opponent indifferent across some responses
This is one of the biggest misunderstandings about solvers. They do not necessarily tell you “always do X.” Often they tell you that several actions are exactly equal in value, and the exact mix depends on the model.
The limits of what a solver can say
A solver is powerful, but it has hard limits.
It cannot know the future actions of real opponents unless you give it those tendencies as inputs.
It cannot solve every possible bet size in every possible line without simplifying the tree.
It may not fully capture:
- multiway pots
- unusual stack depths
- live-read dynamics
- population leaks outside the model
- the cost of rake, if rake is not included
- ICM pressure, if you are studying tournaments without it
- hidden information effects that depend on the full hand history
And it absolutely cannot play the hand for you while you are in action. A solver is a study tool, not a real-time decision engine.
That distinction matters.
A solver tells you what is hard to exploit in the model. It does not tell you what the field actually does at your stakes unless the model includes that field.
How to use a solver well
The best way to use a solver is not to worship its answer, but to learn its logic.
Ask:
- Why does this hand bet?
- Why does that hand check?
- What part of the range wants to use this size?
- What changes if I remove this bet size?
- What changes if I widen or narrow the preflop range?
- What happens if rake or ICM matters?
That is where the real learning happens.
And if you want a place to study those questions away from the table, the Solver module in Poker Exploit gives you the equilibrium strategy of a two-player spot, including turn and river, with the 169-hand grid and result figures. It runs when you ask it to, off the table, and refuses hands from the current session.
The short version
A poker solver works by turning a spot into a game tree, giving each player ranges and allowed actions, then iterating the strategy until it gets close to equilibrium.
Its output is only as good as its inputs.
Its value is not that it predicts the future. Its value is that it shows you the structure of the spot, where the money comes from, and how difficult your strategy is to exploit.
If you learn to read a solver well, you stop thinking in guesses and start thinking in ranges, branches, and tradeoffs. That is a much better way to study poker.
Do it on your own hands.