How Game-Playing AI Learns to Tell a Bot From a Human

The Unlikely Tool 

The research that taught machines to play games at a superhuman level turns out to be the right tool for catching the players who are not human at all. The connection is not obvious, and it is more concrete than it sounds.  

The Lineage That Actually Leads Here 

AlphaGo learned Go from human games, then from playing itself. A year later AlphaZero dropped the human games and learned Go, chess, and shogi from nothing but the rules and self-play. MuZerowent further and learned to plan without being handed the rules at all, by building its own model of how the game behaves. In poker, Libratus and Pluribus ran their version of it over the betting tree.  

Two traditions sit underneath those names. One computes the equilibrium of a game you hand it, which is the counterfactual-regret line behind the poker results. The other learns a representation of how a game and its players behave, from raw experience, which is the deep reinforcement learning line behind AlphaGo. Detection descends from the second one, from the habit of learning to model play rather than from the trophies.  

Detection Is That Model, Run Backward

Our gameplay detection engine is an in-context transformer, the same architecture behind large language models. Where an LLM predicts the next word in a sentence, ours predicts a player’s next action in the context of the hand, reading their history of decisions, each one a situation paired with the action taken.  

The analogy fits because a poker player is telling a story in every hand, start to finish, and just as in a sentence, each action takes its meaning from everything that came before. To predict a player well, the model must learn how that person tells the story. Detection turns the question around: instead of predicting what a player will do next, it looks for the players whose stories do not read as human, because the way AI and humans tell stories in poker is measurably different. 

Run that over everyone and each player becomes a point in a style space, placed by how they decide. Humans land together. Bots land elsewhere. The flag is a player who does not sit with the humans. 

That picture is easy to draw but easy to get wrong. The work lies in how the representation behind it is built. 

How The Representation Is Built, And Why It Is Hard To Fool 

Here is the shape of the network underneath, before the choices that make it work. 

Three design choices do most of the work, and each one is there to stop the model from cheating its way to an easy, useless answer. 

First, the model does not just predict whether a player folds, calls, or raises. It predicts the size of the bet as a separate choice. This matters because a lot of what separates a bot from a person lives in the sizing decisions. A chart-following bot tends to pick the same size in the same spot every time, and the rare, deliberate sizes, an all-in here, an unusual bet there, are exactly where a machine gives itself away. If the model treated every raise as one undifferentiated “raise,” those tells would collapse into a single bucket and vanish. Predicting the size on its own keeps them visible, so a mechanical, too-perfect pattern of sizes reads as exactly that. 

Second, the player representation is read from the layer before the model commits to an action, and the player’s own hole cards are masked out of the input. Both are deliberate. Reading the representation before the action means it encodes how the player was sizing up the spot, not the move they happened to land on, which keeps the answer from leaking into the question. Masking the hole cards means the representation cannot lean on what the player was dealt. It is forced to encode how someone decides in a situation, not how well they ran. That is the real reason a card-dead hour does not fool it: the model was never shown the cards to begin with. 

Third, the representation is shaped by contrast. The model is trained so that two different stretches of the same player’s decisions land in the same place, while two different players land apart. The comparison is held inside a play-style group, so the model cannot take the lazy route of sorting people by crude aggression numbers and calling it done. What comes out of that training is a per-player representation that is stable across sessions and hard to spoof, because it reads the shape of how a player decides across the spots they face, not a handful of surface tells. And it does this from a modest history, a few hundred of a player’s decisions, far short of the tens of thousands of hands a win-rate read would need to say anything at all.

The Sharpest Version: Ask The Model What The Player Would Do 

The most convincing read comes from asking the model what a player would do in spots they may never have played. Build a fixed battery of canonical situations, chosen to be the spots where bots and humans reliably split: a medium hand facing a three-bet out of position, a river bluff with a busted draw, a short-stack shove-or-fold, an unusual bet size to react to. Then use the model to predict what this specific player would do in each of those situations, inferred from their own history. Stack the predicted action distributions together and you have a fingerprint of their strategy. 

Two properties make this powerful. It denoises. A player may never have faced a particular three-bet spot in the hands you hold, but the model can still predict how they would play it, so you get a stable read on a situation they never actually sat in. And it explains itself. Because every probe is a real, legible situation, you can state exactly why an account was flagged: its raise frequency facing a three-bet out of position sits far outside the human range. That is a sentence a human reviewer can check, not a number from a black box.  

Why Grading Move By Move Does Not Work 

There is an obvious shortcut that fails, and it is worth knowing why, because it is the first thing most people reach for. The shortcut grades each move on how bot-like it looks and adds up the suspicion. In poker it breaks on easy spots. Most decisions are forced by the cards. Fold the worst hand, fold the next one, fold again. A human running cold for an hour makes the exact moves a bot would, and a move-by-move score cannot tell them apart, because it is measuring the difficulty of the hands and not the identity of the player. The representation and the probe fingerprint both get around this. They read how a player decides across the situations they face, with the cards masked from the model, so a cold run does not move the read while a real style does. 

Two things that make this genuinely hard: both are the opposite of what you would guess. 

First, we cannot fully trust our own answer key. The accounts we label human are not all human; some are bots nobody has caught. And the bots we have caught are not a fair sample, because the clumsy ones get banned first and the careful ones are still in the pool wearing a human label. So a sharper model that surfaces the hidden ones looks worse on a naive score, since it is flagging accounts the label sheet calls clean. The honest way to handle this is to treat those labels as positive-and-unlabeled rather than ground truth, and to read the metrics as a floor, not a verdict. Building the measurement so that catching a hidden bot counts as a win instead of an error is a real and large part of the work.  

Second, the leverage is not where people assume. More data does help, and it helps most where it counts, in learning the representation of how people play. What saturates fast is the simple classifier that sits on top of a good representation: once the representation is strong, training that last step on ten times more labeled players barely moves it. So the real work, and the place where data and better training actually pay off, is in how the model encodes a player, not in the size of the pile feeding the final yes-or-no.  

What To Look For, And What To Ignore 

There is a tempting and wrong picture of game cheating: a flawless game-theory-optimal bot quietly printing money, and catching it means finding the player who is too good. The bots that actually winare not that. They are automated, they exploit, and they pick soft games, a case made in What the Russian Bots Know That Your Solver Doesn’t. Even Pluribus, the AI the field most often calls a solved game, was a strong agent that won by modeling its opponents rather than a solved one. Nick Petrangelo, who sat at the 2019 table, put it plainly: 

“The bot showed telltale signs of unconverged, undercooked solves. All over the place. A strong agent, clearly. A solved game, no.” 

— Nick Petrangelo (quoted with permission) 

So a detector hunting a superhuman genius is looking for the wrong thing. The signal that matters is in the decisions. Around it sit coarser tells that corroborate: timing that does or does not track the difficulty of the spot, sizing that never varies, and the giveaway no single seat can see, several accounts whose decisions move together in the same games at the same times. Those help. They are not the core. The core is the read on how the player decides. 

One Engine, Two Jobs 

The unit both jobs share is the decision. The model scores how a player decides, spot by spot, against everything it has learned about how people play. For a student, that score is a leak to fix. For a pool, the pattern of those scores, and the representation underneath them, is a signature that reads human or machine. Same decisions, same model, two questions. Coaching and integrity are not two products that happen to share a logo. They are two readouts of one model of how people play. 

What This Actually Means  

It does not claim any detector catches everything. None does, and when ours misses something we would rather find out in the open than pretend otherwise. It does not claim the researchers got their own work wrong; the AlphaGo line and the poker engines are real advances. What it claims is the mapping. A decade of research taught machines to model how players play, and that model, turned around and read off the decisions, is how you tell a human from a bot.