No Training, No Solver: How LLMs Reached Expert-Level Texas Hold'em with PokerSkill

You're sitting at a heads-up no-limit table against GTOWizard—a near-Nash-equilibrium poker AI. You hold 4♥7♠ on a board of 5♥4♣3♥4♠3♠. You have trip fours, an absolutely strong hand.

But Claude Opus 4.6, looking at the same board, says:

> "I'm holding QKo on a 5d4c3h4s board—no made hand at all."

It misread its own hand. That was the real state of LLM poker before 2026: capable of writing essays explaining minimum defense frequencies and analyzing polarized ranges in chat, yet at the table, unable to even 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, outright beating Slumbot, the ACPC 2018 champion bot.

No training, no solver, no game-tree traversal. Just a carefully designed scaffold.

The Decision-Binding Problem: Knowing ≠ Doing

The PokerSkill authors, from Tsinghua University and CUHK-Shenzhen, gave this phenomenon a name: the Decision-Binding Problem.

Imagine you're a medical professor who can recite an entire internal medicine textbook—but when an emergency room patient arrives with fever, rash, and joint pain, you have 30 seconds to decide between dengue and lupus. There is a gap between "knowing" and "doing." You need not just knowledge but a mechanism that activates the right knowledge at the right moment.

LLMs playing poker face the same dilemma. They know pot odds, blockers, polarized betting ranges—but when a single hand involves six dimensions (hand strength, board texture, betting history, position, stack depth, legal raise sizes), the model must pick the one applicable principle out of dozens. It often picks wrong—sometimes failing to even read the board, as in the example above.

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 strategy—what strategy this spot calls for 3. Make a choice—pick one of a few reasonable options

PokerSkill externalizes this cognitive flow 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 identification (~60 scenarios), position, stack-to-pot ratio, and cumulative betting pressure. All of this analysis is deterministic—it never passes through the LLM, so it cannot hallucinate.

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 range tables): exact frequency tables for 12 preflop scenarios
• P3 (general principles): value/bluff separation, positional play, pot control
• P4 (situational strategy): indexed by board texture × hand tier × action line
• P5 (river blockers): blocker-aware bluffing and bluff-catching guidance

The key is selective retrieval: instead of stuffing the whole poker textbook into the prompt, feed only the pages the current spot requires. This avoids two failure modes—vague generic advice, and drowning the model in irrelevant information so it arbitrates among wrong principles.

Stage 3: Bounded Decision

This is the most elegant part. The LLM doesn't roam free in an unbounded action space—it chooses among a set of reasonable actions pre-filtered by a budget system.

Attack/Defense Budget: The Strategic Capacity of a Hand

PokerSkill introduces an intuitively natural concept: every hand has a 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 withstand"—experiential knowledge accumulated over years of play and solver study.

PokerSkill encodes this intuition as an ATT/DEF Budget system:

• 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

This system encodes three GTO insights without any equilibrium computation: 1. Geometric sizing distributes pressure across multiple streets 2. Minimum defense frequencies determine whether to continue 3. Low SPR simplifies to shove-or-fold

The budget system serves the LLM doubly: first, it compresses a complex multi-factor evaluation into a single scalar; second, it enforces multi-street consistency—a flop bet consumes budget, so the turn naturally becomes less aggressive. Without this mechanism, LLMs tend toward locally plausible 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 gets -132; the pure LLM gets -132 to -204; combined, -57 to -87. Neither is strong alone, but together they far exceed either one's ceiling.

A stronger model doesn't mean better poker. Under the default prompt, GPT-5.4 (-178) actually did worse than GPT-5.3 (-160). More reasoning means considering more factors, but with no mechanism to prioritize them, it 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—compared with frequent hallucinated and illegal actions under the default prompt, this is a qualitative change.

The Cracks That Remain

PokerSkill isn't 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 bets with medium-strength hands (half-pot is better), small bets with polarized ranges (big bets are 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 may be classified as "top pair," yet its strategic profile is closer to "two pair." Discrete categories can't fully capture continuous reality.

Multi-street incoherence. Each street's budget is locally reasonable, but the three-street sequence lacks global planning. The flop bet consumes 0.6 budget, the turn 0.8, and by the river, facing a raise, the budget is spent. The 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 isn't poker itself—it reveals a general pattern:

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. The challenge in every domain is not "missing knowledge" but "contextual selection among competing heuristics."

PokerSkill demonstrates an architectural pattern: 1. A deterministic context engine—classify the current situation 2. A curated knowledge base indexed by context—retrieve only relevant knowledge 3. A bounded decision interface—constrain the action space instead of open-ended generation

This pattern can transfer to any sequential decision-making 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 into a deterministic scaffold.

Engineering Notes

• Code is 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 betting-pressure thresholds
• The same skill library works across three different LLMs without modification
• The system is fully deterministic except for LLM calls, and reproducible

PokerSkill's story teaches us: sometimes the bottleneck in AI isn't capability—it's the interface. Give a smart model a bad decision interface and it looks like a fool; give it a well-designed one and the same model plays at expert level.

Rules alone don't make a strong strategy, and LLMs can't play good poker alone. But rules + LLM = expert-level poker with no training and no solver.

Perhaps this is the most elegant form of human-AI collaboration: humans provide structure, the model provides 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