LLM Bots in Poker: What Really Works in 2026

TL;DR

Pure LLMs lose to specialized GTO agents even in maximum reasoning mode. The best result on the April GTO Wizard 2026 benchmark was 16 bb/100 for GPT-5.3 XHigh. Hybrid approaches—PokerSkill, SpinGPT, and ToolPoker—close half of this gap by integrating an LLM as a decision-making interface on top of a deterministic mathematical core. Without this core, the model plays based on intuition rather than theory.

I’ll be honest: when the first LLM bots appeared in poker at the end of 2023—back then it was GPT-4, awkwardly suggesting “fold/call” on the flop after three minutes of deliberation—I was skeptical. Sure, a language model can talk a good game about “maintaining a polarized range on the river,” but poker isn’t just about “tell me about positional play.” It’s about calculating EV under time pressure with incomplete information, where the cost of a single mistake accumulates over hundreds of thousands of hands. Three years later, the picture has changed significantly—and not in the direction of “LLMs have taken over poker,” as the headlines scream, but in a more interesting direction. But let’s take it one step at a time.

A Brief Obituary for “Pure” CFR

CFR and its variations (CFR+, MCCFR, Deep CFR) have given us Libratus, Pluribus, and a whole menagerie of solved and simplified games. There is one architectural problem: the computational complexity of CFR grows exponentially with the number of players, and in multiplayer formats, the Nash-equilibrium strategy loses its guarantee of non-loss. In other words, as soon as the game gets any more complex than a heads-up match, CFR starts to show cracks.

SpinGPT (2025, arXiv 2509.22387) states this explicitly in the motivation section: For Spin & Go (three players, rising blinds, random prize pool), it is possible to build a full-fledged CFR solver, but its practical application in live play is a major engineering headache that few are willing to take on. This is precisely where LLMs have a real window of opportunity.

Why bring LLMs into poker at all?

I’ll start with what convinced me personally. LLMs are naturally well-suited to handling serialized sequences of events: street history, positions, sizing, and stack-to-pot ratio are represented natively as tokens, without the need for forced abstraction of the game tree. This is important for multiplayer.

• Readability of reasoning. Unlike a neural network solver, an LLM explains its line of reasoning. For researchers, this is a goldmine: they can debug an agent’s strategic errors by examining its chain of thought, rather than through a blind analysis of weights.
• Emergent Theory of Mind. A recent paper by Readable Minds (arXiv 2604.04157, April 2026) revealed an unexpected effect: Claude Sonnet agents with persistent memory independently develop a model of their opponent at ToM levels 3–5 (predictive and recursive modeling) after several hundred hands. Without memory, they remain stable at Level 0. This is no longer mere imitation; it is emergent behavior—and this is precisely what makes LLM-based poker AIs fundamentally interesting subjects for research, rather than just another set of bots.

What really works in 2026

PokerSkill: No solver, no fine-tuning

A paper from Tsinghua and CUHK (arXiv 2605.30094, May 2026) is perhaps the most elegant architectural achievement of the year. The idea is almost indecently elegant: a deterministic contextual engine analyzes the current state of the table and selects relevant fragments from a library of poker skills written by experts. The LLM does not choose from an infinite space of actions—it is presented with a limited, strategically sound set of options.

Results against GTOWizard (in mbb/hand — milli-big-blinds per hand):

For context: a basic prompt without any skills yields between −140 and −200 mbb/hand. Reducing the loss by nearly half without a single training iteration and without using a solver is an engineering-wise result.

SpinGPT: The Hybrid That Took Off

SpinGPT took the straightforward approach—two-stage training on top of a base LLM:

1. SFT on 320,000 high-stakes expert decisions—the model absorbs the language of poker from the context of real games, not from synthetic data.
2. RL on 270,000 hands from the solver—the solver’s GTO response is used as a reward signal. The model learns not to mimic the solver token-by-token, but to aim for its solutions.

Results: 78% agreement with the solver (tolerant accuracy) and +13.4 ±12.9 BB/100 against Slumbot in a 30,000-hand heads-up match. This isn’t just “almost like a solver” anymore—it “plays like a strong NL400 reg.”

ToolPoker: An Agent with Tools

Microsoft Research (arXiv 2602.00528, January 2026) first thoroughly documented why a “pure” LLM fails, and only then proposed a solution. Three systemic flaws:

• Reliance on heuristics. The LLM makes a check-raise “because the hand is strong,” not because it maximizes EV given the ranges.
• Factual errors. The model gets confused about the probabilities of combinations, overestimates the flush draw, and miscalculates outs. It’s not because it’s dumb—it’s just that precise probability calculations tend to “drift” under the pressure of a long context, leading to results that are similar to what the training data suggests but not exactly the same.
• The knowing-doing gap. The most troublesome of the three and the most systemic. In its chain-of-thought, the model reasons correctly and lays everything out properly—and then performs a different action. This bug reproduces consistently across all models and isn’t cured by a better prompt.

ToolPoker addresses all of this with a single solution: an external poker solver becomes a tool within the reasoning loop. The LLM formulates a query to the solver (current spot, ranges, history), receives a GTO-consistent action, and only then generates an explanation. This is no longer “the LLM plays”—it’s “the LLM conducts the orchestra.”

The Bottom Line: API Costs in Real-World Setups

This is where the engineering reality begins—the kind that isn’t covered in academic articles. Based on current price lists as of June 2026:

A single poker hand with full context (betting history, stacks, ranges, chain-of-thought reasoning) is approximately 2–4k tokens on the input and 300–600 tokens on the output. On Claude Opus 4.7 without caching, that’s ~$0.015 per hand. 500 hands per hour cost $7.50 just for the API. When caching the system prompt (skill library, game rules, position descriptions), cached reads cost $0.50/1M versus $5.00/1M, which means a 90% savings on input context—and the numbers immediately become reasonable.

Gemini 3.1 Flash-Lite, with its 1M-token context window, technically allows you to load an entire session and update the opponent’s model in real time at a cost of $0.25 per 1M. The quality of reasoning doesn’t quite match that of Opus yet, but for prototyping and experimenting with ToM agents, it remains the cheapest option with sufficient context.

Why a pure LLM still loses to GTO

The main question about LLM bots in poker today isn’t “whether they can play at all,” but “exactly how far behind GTO they are and why.” In April 2026, GTO Wizard published a benchmark using the AIVAT methodology (variance reduction, which reduces the number of hands required for statistical significance by a factor of 10). All the top LLMs played 5,000 heads-up hands each against their specialized agent:

The best result was GPT-5.3 XHigh at −16 bb/100. It sounds like “almost there,” but at the NL200 level, that translates to hundreds of thousands of dollars in negative EV per year. GTO Wizard AI itself posted a result of +19.4 bb/100 against Slumbot over 150,000 hands.

The root of the problem is systemic. The LLM is optimized to predict the next token based on the training distribution. Poker requires something else: a minimax search in a tree with incomplete information, where the most valuable spots are precisely those that rarely occur in the training sample. On the river, with a non-standard stack-to-pot ratio and an unreadable flop line, the LLM does what any language model does in an out-of-distribution (OOD) scenario—it interpolates where it’s least expected.

This was also confirmed by the October PokerBattle.ai tournament (2025): Among the top nine LLMs ($10/$20 NLHE, 3,799 hands, live bankroll), OpenAI o3 took the crown with a VPIP of 26%, while Meta’s Llama 4 went bust first with a VPIP of over 60%. The difference between the best and the worst lies not in “intelligence,” but in the discipline of how often they enter pots. And this is determined by prompting, not by architecture.

Right now, I’m less concerned with the question “When will an LLM outperform GTO Wizard?” and more with another one: at what point will native tool-use within the RL loop make calling the solver an organic part of the agent’s reasoning—not because we specified it in the system prompt, but because the reward signal during training encourages it. PokerSkill and ToolPoker have demonstrated that the principle works. SpinGPT has shown that RL on solver data scales. The next step is to train a model that decides for itself when it needs the solver and when the skill library is sufficient. The easiest way to track progress is via PokerBench on GitHub—new results are regularly posted there by teams that aren’t waiting for the NeurIPS deadline to share their numbers. I’m willing to bet that the best LLM poker bots of 2027 will look exactly like this.