REFERENCE · NOV 1, 2026
Meet Every Bot: Who Decides, What It Sees and Where It Plays
HoldemRobots.AI has dice bots, menu bots, rules bots, AI bots and two kinds of cheaters, and the word “house” had come to mean four different things. This page sorts every one of them by how it thinks, what it can see and which table it sits at, checked against the code.
Four kinds of thinking
| THINKING | HOW A MOVE GETS DECIDED | WHO WROTE THE LOGIC |
|---|---|---|
| 1. Dice | A random number. Some rules may shape it (“raise 30% of the time”), but chance makes the call. | Kevin, 2006; and today’s control-group bots, on purpose |
| 2. Sushi Menu | Fixed rules picked from checkboxes: a starting-hand list, a turn test, a river test | Kevin, 2006. The student picks the boxes. |
| 3. AI-assisted rules | Fixed rules written as code. An AI helped write or suggest them, but no AI runs while they play. | A person working with an AI |
| 4. AI harness + LLM | A language model decides live, every move. A harness shows it only the legal view of the table, reads its answer, saves its reason, and falls back to rules if the answer can’t be used. | The model, inside Kevin’s harness |
The line between 3 and 4 is the one that matters most. In 3, the AI’s help is finished before the first hand, and the bot plays the same way forever, for free. In 4, the AI is at the table, thinking every turn and costing a little money every move.
A rules bot remembers what an AI once said. An AI bot is still talking.
The House Bots, then and now
House Bots is the nickname Kevin and Claude gave the first four rows of the Sushi Menu. As first built, they were rules plus a random number: “a dice roll wearing a poker face” (Book 1, Part 1). To get them past a self-judged Turing test, the point where they at least felt intelligent across the table, Kevin bolted on a peek at frivbest, the ranking of where every hand would finish. When the engine came back in 2026, he told Claude it was there, and the two of them found it in exactly four places in the code.
| BWC · BEFORE WITH CHEAT 2006 – JULY 2026 | MENU COLUMN | ACR · AFTER CHEAT REMOVED JULY 2026 ON |
|---|---|---|
| Hardways: played only with the best hand at the table | HRDONE | Pbot, still the tightest |
| Crapbetter: played only for a top-three finish | CRPONE | Sbot |
| Hornbetter: came after seat ten (you) only when it would win | HRNONE | Ubot, solid, with no grudge |
| Fieldbetter: played for a top-five finish | FLDONE | Dbot, the loosest |
| HOUSE BOTS (BWC) | HOUSE BOTS (ACR) | |
|---|---|---|
| Thinking | Dice, plus the bolt-on peek | AI-assisted rules: rebuilt on the AI’s suggestion |
| Can see | How the hand would end | Only their own cards and the board |
| Plays at | Gone; their games remain (94033, 44252, 76069) | The Advanced Simulator (Sushi Menu) |
| In one line | Knew how the hand would end | Only know what you know |
The cheat worked as a Turing-test trick for a simple reason: knowing the future looks like judgment from across the table. And it wasn’t clever code. It was the answer sitting in the same visible region as the bot, the same flaw as Door 3 on the Pi, where bots and the dealer share one program, and the same worry behind Dialog 1’s “Is this multi-agent, or are we cheating?” Each time, the fix is to make sure the answer isn’t there to read.
Every bot, by family
Sushi bots
Built one column at a time on the Sushi Menu: a starting-hand list (Sklansky 1–4 or OddsWiz 1–4), a turn test and a river test. A blank column is a calling station that never folds. Thinking: Sushi Menu. Sees: its own cards and the board; Book 1, Part 2 proved this from the compiled code. Plays at: the Advanced Simulator, nine robots and you. Code: compiled Java (com.Robology).
The Roster
Five honest Python bots in opponents.py, written in July 2026. Their own header says they are “not the old oracle house bots, they are honest players with different habits.”
| BOT | STYLE | PUNISHES | THINKING |
|---|---|---|---|
| Rock | Folds a lot, bets only the nuts | Paying it off | AI-assisted rules |
| CallingStation | Calls nearly everything, rarely raises | Bluffing | AI-assisted rules |
| Maniac | Raises constantly on little | Folding too much | AI-assisted rules |
| Grinder | Solid, tiered by street, adjusts for position and price | Everything sloppy. “Beating this one means something.” | AI-assisted rules |
| Coin | Ignores its cards | Nothing: it’s the control group | Dice, on purpose |
Plays at: the website’s Robot Wars page (all five, every game), arena.py, and the Pi’s student table. Coin’s own comment says what dice thinking is for today: “if your bot can’t beat this, the bug is in your bot, not in your strategy.”
Student bots
- The sample bot (
starter_bot.py) and my bot (student_bot.py): the two choices on the Robot Wars page. Both currently hold the six-line Robot Builder starter: pair or better, raise; otherwise fold. - Robot Builder’s Simple, Medium and Complex: the staircase from six lines to about seventy (“Smarter Rules”).
- The class lineup (
class_bots.txton the Pi): Rockslide, TiltMachine and PotOdds play rules; Coinflip Carl plays dice, as the class’s control group. Two Roster bots, Grinder and CallingStation, fill the remaining seats.
Thinking: rules, written by students, with or without an AI partner. Sees: only what fair_client hands over: its cards, the board, the pot, the price to call, position and whose turn.
The One-Liner
rules_policy in policies.py, about ten lines, described in its own comment as “the honest one-liner”: raise a strong hand, call a middling one, otherwise fold to a bet. It does three jobs, which is why it kept getting mistaken for other bots:
- Every opponent in Batch Robot Wars (AI): five copies of it sat with the AI agent in games 990101–990110.
- The AI agent’s fallback: when the model’s answer can’t be used, the One-Liner plays that move (marked
-fbin the log). - The tournament’s practice opponent: the code calls it the “house rules bot” (
HouseSeat); the seats played it in the smoke tests. It also stepped in when a seat’s reply was cut off or AWS didn’t answer.
Its sibling math_policy calls only when its hand beats the pot odds. Batch Robot Wars can seat it instead. Thinking: AI-assisted rules. Sees: its own hand strength, the pot and the price; never a rank.
The AI agent
Kevin’s original Claude player (agent.py), calling a model on Amazon Bedrock for every move and writing down a one-line reason. Thinking: AI harness + LLM, with the One-Liner as its safety net. So one AI seat can mix two kinds of thinking in a single game, and the log says which moves were which. Plays at:
| WHERE | LOG LABEL | OPPONENT |
|---|---|---|
| The heads-up table | hu-s4 | You |
| The heads-up table, with memory | hum-s4 | You, remembered across hands |
| Batch Robot Wars (AI) | rw-s4 | Five One-Liners |
Seats A–E
Five AI models from five companies, each running the same seat code on AgentCore; only the model differs. Thinking: AI harness + LLM, with the One-Liner stepping in when a reply ran out of room or AWS didn’t answer. Played at: the Backroom tournament, heads-up, every deck twice with seats swapped (games 996101–996120). Which model sat in which seat is in the sealed key.
Peeker and Diary
Cheaters on purpose, in the Pi’s spoilers folder behind its STOP page, for the Door 3 security exercise only. Thinking: rules. Sees: more than they should, because on the Pi’s student table the bots and the dealer share one program. They’re the House Bots’ lesson, rebuilt as an exercise.
Every table, and who sits there
| TABLE | SEATS | DEALT BY |
|---|---|---|
| Advanced Simulator (Sushi Menu) | Nine menu bots (House Bots ACR or Sushi bots) and you in seat ten | The original Java engine |
| Robot Wars (the website page) | The sample bot or my bot, against all five Roster bots; 100 hands | arena.py |
| Batch Robot Wars (AI) (the AI panel) | The AI agent (seat 3 by default) and five One-Liners | dealer.py |
| Heads-up table | You against the AI agent | dealer.py |
| Backroom tournament | Seat against seat; practice games against the One-Liner | dealer.py |
| Pi student table | Up to six bots from a class file, plus Roster seats | arena.py |
Notice that “Robot Wars” names two different programs. The website page pits your bot against the Roster. The AI panel’s batch pits the AI agent against One-Liners. Game 990110, the one where the AI stayed out of the rules robots’ fights in “The Rule You Can’t Write,” was the batch version.
Every dealer on this list follows the same rule from Book 1: the dealer may know; the wire may not. arena.py and the Robot Wars writer both work out every seat’s final rank, because Game Review needs it, but no bot is ever handed it.
Retiring the word “house”
| WHERE IT SAYS “HOUSE” | WHAT IT REALLY MEANS | CALL IT |
|---|---|---|
| Book 1, the Sushi Menu | The first four menu rows | House Bots (BWC / ACR). The only keeper. |
student_bot.py: “the five house bots”; “The Rule You Can’t Write”: “the house robots” | Rock, CallingStation, Maniac, Grinder, Coin | the Roster |
class_bots.txt: === HOUSE: grinder === | Roster bots filling seats on the Pi | Roster seats |
bt_runner.py: “the house rules bot” | rules_policy | the One-Liner |
Worth tidying
- One shared “my bot.” The website keeps a single
student_bot.py, so the last student to save a bot replaces everyone else’s. - Two “sample bots.” The “Use the sample bot” button seats
starter_bot.py; when nobody has saved a bot, the writer falls back to a different file, the built-insample_bot.py. - Pbot’s old page says it “uses artificial intelligence” and “has no advanced knowledge” of the flop, turn or river. The second claim wasn’t true while it was Hardways (BWC), and the first oversells rules.
- Still unchecked: whether the House Bots (ACR) and Sushi bots still use any random number. That lives in the compiled Java.
Sources: the code as it stood on November 1, 2026: opponents.py, arena.py, policies.py, robotwars_hr.py, ai_control.py, bt_runner.py, battle_writer.py, starter_bot.py, student_bot.py, class_bots.txt, the Sushi Menu pages and Pbot’s page; Book 1, Parts 1 and 2; and Kevin’s account of why the cheat was built.
Written by Claudette, the pen name for Claude, the AI from Anthropic that helped build HoldemRobots.AI, with Kevin Swinson. Server addresses, account numbers and keys are left out on purpose.