Poker Isn't Solved: Opponent Modeling and Exploitation Are Still Open Problems

There's a comfortable story about computer poker that goes like this: Libratus beat the pros in 2017, Pluribus beat them six-handed in 2019, and the science is finished. Poker, like checkers and chess and Go, has been handed over to the machines. Move on.

That story is wrong in a specific and interesting way. It collapses two things that should never have been collapsed:

1. Play approximate-Nash poker at superhuman level in heads-up and 6-max no-limit. This is done. The results are real and they are not in dispute.
2. Solve poker as a science problem. This is not done. It isn't close to done.

The second is what bot builders actually find interesting. It's also the question Chipzen is built to host. This post is about why the "poker is solved" narrative stuck, what it gets wrong, and why the open problems past Nash are the ones worth a platform.

What Libratus and Pluribus actually showed

Both results are landmark achievements, and being precise about them is not a knock. Here is what they demonstrated:

A blueprint strategy, trained with counterfactual-regret methods (how that works), plus real-time subgame solving at the table, can approximate a Nash equilibrium closely enough to beat the best humans - in narrow settings, with enormous compute. Libratus ran on the Bridges supercomputer. Pluribus was cheaper but still well beyond a hobbyist's budget at training time.

What they did not show is that the harder problems past equilibrium had been resolved. Approximating Nash is one question. It is not the only question, and for a competition between bots it may not even be the most important one.

The conflation stuck for an ordinary reason: a single dominant narrative ("AI solved poker") is easier to remember than a calibrated one ("AI can approximate equilibrium in two specific formats given a supercomputer"). Headlines round off the footnotes. The footnotes are where the open research lives.

Why Nash isn't the end of the story

A Nash-equilibrium strategy in a two-player zero-sum game - heads-up poker is one - has a remarkable property: it is unexploitable. No opponent can beat it in the long run, no matter how they play. (Add a third player and even this stops holding cleanly, which is part of why multiplayer is harder; set that aside for now.)

It has an equally important second property that gets far less attention: it doesn't exploit. A Nash strategy doesn't deviate to punish a weak opponent's leaks - it collects only what equilibrium play already wins, and leaves the rest on the table against anyone who isn't also playing equilibrium.

And here is the thing every working bot builder knows: every real opponent is not playing equilibrium. Real opponents have leaks. They fold too much from the big blind, or they over-bluff rivers, or they size their bets in tells. Against that population, the gap between "play unexploitable" and "play the best response" is large - often much larger than the edge a Nash bot holds over another Nash bot.

So the interesting question for competitive poker isn't "can you approximate Nash." That's a solved recipe. The interesting question is: can you model the specific opponent in front of you and deviate toward exploiting them, without opening yourself up so much that a strong opponent punishes the deviation?

That problem is open.

Opponent modeling is still hard

Estimating an opponent's strategy from observed play - at a competition-realistic resource and sample budget - is genuinely unsolved.

The difficulties stack on each other. You see only a sample of the opponent's actions, and only at the info sets that actually came up. You have to infer their strategy at info sets you've barely observed. You have to do it online, while the match is happening, fast enough to act on. And you have to balance exploitation against the risk that your read is wrong - or that the opponent is adapting to you in turn.

There's prior art. The safe-search and continual-resolving literature out of the Alberta and CMU groups (Burch, Schmid, Bowling, and others) - re-solving the current subgame from scratch at decision time, with guardrails that keep the deviation from making you exploitable - gives you a way to deviate from a blueprint without handing the edge back. More recent work has tried to fold online opponent models into that machinery. But "robust online opponent modeling at a bounded compute budget" is a research frontier, not a settled technique. Nobody has a turnkey answer.

Evaluating exploitation is also hard - and that's the deeper problem

Here's the part that doesn't get enough attention: even if you build an exploitative bot, measuring whether it's any good is its own unsolved problem.

To say "bot X exploits opponent class Y by Z big blinds per 100," you need a definition of class Y and enough distinct opponents instantiated within it to get a statistically meaningful number. That's hard to construct and harder to standardize.

The ACPC (the competition that ran this era) hit exactly this wall. It ran two brackets: a total-bankroll bracket (roughly, who wins the most, which rewards exploitation) and a bankroll-instant-runoff / least-exploitable bracket (who is hardest to beat). The exploitation-flavored bracket was always the harder one to make scientifically meaningful, because the result depended entirely on which opponents happened to enter that year.

Most academic publications dodge the problem. They either evaluate against a fixed set of scripted opponents - which measures exploitation of those specific scripts, not exploitation in general - or they retreat to exploitability against a best-response, which is a Nash-distance measure, not an exploitation measure. Those are different questions wearing the same clothes.

Why a live platform is the right testbed

This is where a competition platform earns its keep, and it's the specific bet Chipzen is making.

Opponent modeling and exploitation can only be measured against real, varied, evolving opposition - not a frozen panel of scripted bots. A scripted opponent has a fixed leak; beating it tells you that you can beat that leak, once. A live ladder of other people's bots, improving over time, is a moving population that a modeling approach has to actually work against.

Two things a live platform provides that an offline benchmark doesn't:

Named, evolving opponents. Your exploitation strategy gets tested against bots that other builders are actively trying to make unexploitable. That's a far stronger test than vs-Random or vs-CallStation, where the leak never narrows and any bot looks like a genius.

Enough hands to make the gap measurable. Exploitation edges are smaller and noisier than "did I beat a fish," so they need volume. Screening-tier head-to-head counts - the low-thousands of hands many academic events ran on - aren't enough to promote a borderline exploitation result; those routinely collapse at larger samples. You need five to ten thousand hands of head-to-head minimum before an exploitation edge is real signal rather than variance. A continuous ladder produces those counts as a matter of course.

That's the platform argument, stated once: if the open problem in poker is exploitation, the thing the field is missing is a place to measure it against live opposition at honest sample sizes. That's what we're building.

Who this is for

If you think poker is done, this post probably wasn't for you. If you've ever watched a "GTO" bot leave money on the table against an obvious fish and thought there's a whole research problem hiding in that gap - you already get it.

We're especially interested in two kinds of builder:

• People betting on the exploitation thesis, not just the Nash thesis - who want to model and deviate, and want real opponents to do it against.
• Researchers who want a live testbed for opponent modeling that escapes the scripted-opponent and vs-Random blind spots that quietly invalidate a lot of published evaluation.

And if you competed in the ACPC era and have been waiting for a public arena since it wound down: the door's open. Poker isn't solved. The interesting part is just getting started.

Bring an exploitative bot and get real head-to-head numbers against named, evolving opposition.