No Training, No Solvers: How LLMs Play Expert-Level Texas Hold'em with PokerSkill
Imagine sitting at a heads-up no-limit table against GTOWizard, a near-Nash-equilibrium poker AI. You hold 4♥7♠ on a 5♥4♣3♥4♠3♠ board — trip fours, an absolutely strong hand.
Yet Claude Opus 4.6, looking at the same board, said:
> "I have QKo on a 5d4c3h4s board — no made hand at all."
It couldn't even read its own cards. That was the real state of LLM poker before 2026: able to write essays explaining minimum defense frequencies and analyze polarized ranges eloquently, but at the table, unable to count the fours in its own hand.
Then PokerSkill arrived. The same Claude Opus 4.6 saw its loss rate drop from -204 to -80 mbb/hand, a 61% improvement. GPT-5.5 went from -132 to -57, surpassing Slumbot, the ACPC 2018 champion bot.
No training, no solvers, no game tree search — just a carefully designed scaffold.
The Decision-Binding Problem: Knowing ≠ Doing
The PokerSkill authors, from Tsinghua University and The Chinese University of Hong Kong, Shenzhen, named this phenomenon the Decision-Binding Problem.
Think of a medical professor who can recite an entire internal medicine textbook, but faces an emergency patient with fever, rash, and joint pain and has 30 seconds to decide between dengue and lupus. There is a gap between "knowing" and "doing": you need a mechanism to activate the right knowledge at the right moment.
LLMs playing poker face the same dilemma. They know pot odds, blocker cards, and polarized betting ranges — but when a single hand involves six dimensions simultaneously (hand strength, board texture, betting history, position, stack depth, legal raise sizes), the model must select the one principle that applies *now* among dozens of candidates. It often picks wrong — sometimes failing to even read the board.
A Three-Stage Pipeline: Thinking Like a Pro
PokerSkill's core insight comes from a simple observation: professional poker players don't derive game theory from scratch on every hand.
Their thought process is: 1. Read the situation — board texture, position, opponent's action line 2. Recall — retrieve the strategy appropriate for this spot 3. Choose — pick among a few reasonable options
PokerSkill externalizes this cognitive process into three stages:
Stage 1: Context Engine
A set of deterministic rules analyzes the current state: board classification (dry/wet/flush/straight), hand classification (23 tiers, from nuts to trash), action line recognition (~60 scenarios), position, stack-to-pot ratio, and cumulative bet pressure. None of this passes through the LLM, so there are no hallucinations.
Stage 2: Skill Retrieval
Context tags select relevant snippets from a five-layer skill library:
- P1 (always active): game rules, legal actions, output format
- P2 (preflop ranges): precise frequency tables for 12 preflop scenarios
- P3 (general principles): value/bluff separation, positional strategy, pot control
- P4 (situational strategy): indexed by board texture × hand tier × action line
- P5 (river blockers): blocker-aware bluffing and bluff-catching guidance
- Each hand receives an attack budget B_att and defense budget B_def based on its tier and context
- Each bet consumes budget, proportional to bet size
- Budget exhausted = no reasonable action remains in that direction
- Open source: https://github.com/lbn187/PokerSkill
- The entire skill library (all prompt snippets, budget tables, context tags, action constraints) was designed by human poker experts, covering ~60 action-line scenarios, 23 hand tiers, and 46 bet-pressure thresholds
- The same skill library works across three different LLMs without modification
- The system is fully deterministic except for LLM calls, and reproducible
The key is selective retrieval: instead of stuffing the whole poker textbook into the prompt, feed only the pages the current spot needs. This avoids two failure modes — vague generic advice, and too much irrelevant information causing the model to arbitrate between wrong principles.
Stage 3: Bounded Decision
This is the most elegant part. The LLM doesn't act freely in an unbounded action space; it chooses from a set of reasonable actions pre-filtered by the budget system.
Attack/Defense Budget: A Hand's Strategic Capacity
PokerSkill encodes an intuitive notion: each hand has finite strategic capacity.
Top pair can value-bet two streets and defend three. Middle pair can only defend one or two streets before it should fold. Professionals have a clear intuition for "how much pressure this hand can bear," accumulated from years of play and solver study.
PokerSkill encodes this intuition as the ATT/DEF Budget system:
This system encodes three GTO insights without any equilibrium computation: 1. Geometric sizing distributes pressure across streets 2. Minimum defense frequencies determine continuation 3. Low SPR simplifies to shove-or-fold
The budget system serves the LLM twice over: first, it compresses a complex multi-factor evaluation into a single scalar; second, it enforces multi-street coherence — a flop bet consumes budget, so the turn naturally becomes less aggressive. Without this mechanism, LLMs tend toward locally reasonable but globally incoherent decisions.
The Numbers
AIVAT results against GTOWizard (a near-Nash GTO benchmark):
| Agent | Method | Loss rate (mbb/hand) | |-------|--------|----------------------| | GPT-5.5 XHigh | PokerSkill | -57 ± 21 | | Claude Opus 4.6 | PokerSkill | -80 ± 29 | | Claude Opus 4.7 | PokerSkill | -87 ± 64 | | Pure rule engine (no LLM) | PokerSkill rules only | -132 ± 19 | | GPT-5.5 XHigh | Default prompt | -132 ± 25 | | Slumbot (ACPC 2018) | Solver | -194 ± 41 | | Claude Opus 4.6 | Default prompt | -204 ± 44 |
Key findings:
1 + 1 > 2. The pure rule engine scores -132; pure LLMs score -132 to -204; combined, -57 to -87. Neither is strong alone, but together they far exceed each one's ceiling.
A stronger model doesn't mean better poker. Under the default prompt, GPT-5.4 (-178) was actually worse than GPT-5.3 (-160). Stronger reasoning means considering more factors, but without a prioritization mechanism, it just gets messier. PokerSkill's scaffold eliminates this scaling paradox.
Validation failure rate < 0.1%. Choosing within a bounded action space, the LLM almost never produces illegal moves — a qualitative change from the frequent hallucinations and illegal operations under default prompts.
Remaining Cracks
PokerSkill is not a silver bullet. The paper honestly identifies three persistent error patterns:
Sizing misjudgment. The budget correctly allows a bet, but the LLM picks a suboptimal size — full-pot with medium-strength hands (half-pot better), small bets with polarized ranges (big bets better). Binary bet/check decisions are easier to activate than continuous sizing choices.
Blurry category boundaries. Hand classification is discrete, but hand strength is continuous. Top pair with a weak kicker gets labeled "top pair," yet plays closer to "two pair." Discrete categories can't fully capture continuous reality.
Multi-street incoherence. Per-street budgets are locally sensible, but the three-street sequence lacks global planning. A 0.6 flop bet plus a 0.8 turn bet leaves insufficient budget when facing a river check-raise. The budget system lacks lookahead — it cannot foresee that a turn bet creates an uncomfortable river spot.
Why This Is Bigger Than Poker
PokerSkill's real significance lies not in poker but in a general pattern it reveals:
The decision-binding problem is everywhere. Medical diagnosis must bind symptoms to the right differential; legal reasoning must bind case facts to relevant statutes; business negotiation must bind the current offer to the right concession strategy. In every domain, the challenge is not "lacking knowledge" but "making a contextual choice among competing heuristics."
PokerSkill demonstrates an architecture pattern: 1. Deterministic context engine — classify the current situation 2. Curated knowledge base indexed by context — retrieve only relevant knowledge 3. Bounded decision interface — constrain the action space instead of open-ended generation
This pattern transfers to any sequential decision domain where expert knowledge exists but LLMs struggle to activate it reliably. No fine-tuning, no reinforcement learning — just externalize the expert's cognitive pipeline as a deterministic scaffold.
Engineering Notes
Rules alone don't make a strong strategy, and an LLM alone can't play good poker. But rules + LLM = expert-level poker with no training and no solver.
That may be the most elegant form of human-AI collaboration: humans provide structure, models provide judgment.
---
Paper: PokerSkill: LLMs Can Play Expert-Level Poker without Training or Solvers Authors: Boning Li (Tsinghua), Baoxiang Wang (CUHK-Shenzhen), Longbo Huang (Tsinghua) arXiv: https://arxiv.org/abs/2605.30094 Code: https://github.com/lbn187/PokerSkill