agents play poker

I made 6 LLMs play Texas Hold'em. Not a toy version. Real poker with betting rounds, position play, bluffing, and side pots. The smallest model won.

// the experiment

I wanted to see what happens when you put language models in a competitive, time-pressured environment where being "correct" isn't always the same as winning. Poker felt right. It rewards deception, aggression, and reading opponents. Things LLMs aren't supposed to be good at.

The setup: 5 tournaments, 6 models, $1M buy-in, 25 hands per tournament. Two small models running locally on my MacBook via LM Studio (Liquid at 1.2B params, Qwen at 1.7B). Four cloud models (MiniMax at 230B, GPT-OSS at 120B, Claude Haiku, and Kimi at roughly 1 trillion parameters).

Each model gets the same information every hand: hole cards, community cards, a Monte Carlo equity estimate (500 simulations), opponent betting patterns, pot size, and valid actions. They respond with a number. Raise, call, fold, or all-in. No chain-of-thought, no reasoning traces. Just a decision.

Built with Hive for agent orchestration and pokertable for the game engine. Each model plays through Hive's multi-model routing, same interface regardless of provider.

// the results

R/F Ratio = raises per fold. Higher means more aggressive.

The two smallest models finished first and second. A 1.2B model running on a laptop beat models 100 to 800 times its size. Liquid won 2 out of 5 tournaments. The trillion-parameter model averaged last place.

// why small models won

The strongest predictor of tournament success wasn't model size, hand win rate, or sophistication of play. It was the raise/fold ratio.

Liquid and Qwen both had a R/F ratio of 5.89. For every fold, nearly 6 raises. GPT-OSS had 0.65. More folds than raises. In a 25-hand tournament with high blinds, that math kills you. Every hand you fold, the blinds eat your stack. The "correct" fold costs you money you can't afford to lose.

Claude Haiku is the most interesting case. It played textbook-correct poker. Fold bad hands, raise good ones, size bets appropriately. And it placed 4th or 5th in every single run. Never terrible. Never good. The polite player who does everything right gets ground down by the maniac who raises everything.

GPT-OSS was the extreme case. In one run: 0 raises and 5 folds across 6 hands. It correctly assessed that its hands were weak. But correct folding is a losing strategy when the blinds eat your stack faster than you can win pots. Being right about hand strength while being wrong about strategy.

There's something deeper here. The larger models seem to have internalized caution during RLHF training. They hedge. They play conservatively when uncertain. The small models with less alignment training just default to aggression. In poker, that recklessness is an advantage.

// what I learned building it

Hive's multi-model routing made this possible. One framework, six different LLM providers, same agent interface. Each model gets a poker persona through Hive's persona system.

The hardest part wasn't the poker engine. It was getting models to output valid actions consistently. Larger models want to explain their reasoning. They write paragraphs about pot odds before giving you a number. Smaller models just pick a number. Turns out that's an advantage when your entire interface is "respond with 1 through 4."

Speed mattered too. Liquid averaged 5.6 seconds per decision. Kimi needed 60+. In a fast-paced tournament, that latency gap compounds.

// what's next

Five tournaments is a provocative signal, not proof. Two experiments are coming:

Scale: Running 200 to 1000 games to get statistical significance. The aggression hypothesis needs volume to confirm. Maybe the small models got lucky. Maybe they didn't. Only one way to find out.

Personality isolation: Running 4 to 6 identical models (same weights, same provider) with different personas. Does a "cautious" persona on Liquid still win? Does an "aggressive" persona on Haiku do better? This separates the model variable from the persona variable.

All the code is open source. The poker engine is on PyPI. The arena runs on Hive. If you have a local LLM setup, try running a tournament yourself.