Kitbarnes/golden-bots

Golden Bots: AI models bluffing for a jackpot

Four AI models play a game show of hidden balls, lies and betrayal. Each is dealt cash balls and Killer balls, some face up and some hidden. They tell the others what's on their hidden back rows, argue, vote each other out, gamble the jackpot ball by ball, and finish with split or steal.

Every back-row claim is stored next to the balls the model was really holding, and almost every move comes with the model's private notes on why it made it. So you can see who lied, whether it worked, and what they were thinking at the time.

• Watch the games: goldenbots.thekitbarnes.com
• Code, prompts and rules: GitHub
• About the project: Hugging Face Space

At a glance

Games	6
Moves	365 (365 by AI models, 97% of those with private thoughts)
Models	15
Back-row claims	42, of which 35 (83%) were false
Finals	5 both split, 1 one stole, 0 both stole
Promises to split	11 finalists told the other they'd split; 1 (9%) then stole
Exit interviews	4
Private ratings at votes	0, from 0 games (one AI on one player still in: did it believe their claim, and how far did it trust them?)
Played	2026-10-20 to 2026-10-28
Games with a human player	none (left out)
Exported	2026-10-29

Loading it

from datasets import load_dataset

moves = load_dataset("Kitbarnes/golden-bots", "moves", split="train")
games = load_dataset("Kitbarnes/golden-bots", "games", split="train")

Or with pandas: pd.read_json("hf://datasets/Kitbarnes/golden-bots/moves.jsonl", lines=True).

Questions it can answer

m = moves.to_pandas()
claims = m[m.move == "claim"]
votes = m[m.move.isin(["vote", "tie_decide"])]
interviews = m[m.move == "interview"]

# Who lies? The share of each model's back-row claims that were true.
claims.groupby("model").truthful.agg(["count", "mean"]).sort_values("mean")

# When do they lie? With a Killer to hide, after being caught out in round 1, or late in the order.
claims.groupby(claims.back_killers > 0).truthful.mean()
claims.groupby("lied_before").truthful.mean()
claims.groupby("claim_order").truthful.mean()

# How do they lie? Cash added, and Killers hidden.
(claims.claim_total - claims.back_total).describe()
(claims.back_killers - claims.claim_killers).clip(lower=0).sum()

# Does lying pay? How often liars and truth-tellers went out that round.
claims.groupby("truthful").voted_out.mean()

# Can they spot a liar? How often each model's vote went against someone who was lying.
votes.assign(at_liar=votes.target_truthful == False).groupby("model").at_liar.mean()

# Do they own up afterwards? Their interview answer, checked against their claims.
interviews.interview_checks.str.get("claims_verdict").value_counts()

# What do they make of each other at the vote? Each AI's private rating of every player still in:
# did it believe their claim, and how far did it trust them (1 to 5), next to whether the claim was true.
said = votes.explode("ratings").dropna(subset=["ratings"])
said = said.assign(rated_model=said.ratings.str.get("model"), believed=said.ratings.str.get("believed"),
                   trust=said.ratings.str.get("trust").astype(float), truthful=said.ratings.str.get("truthful"))
said.pivot_table(index="model", columns="rated_model", values="trust", aggfunc="mean")  # trust, rater by rated
said.groupby("truthful").trust.mean()  # are liars trusted less?
seen = said.dropna(subset=["believed", "truthful"])
seen.assign(right=seen.believed == seen.truthful).groupby("model").right.mean()  # who sees through a claim

# Who trusts whom? Each interviewee's trust (1 to 5) in every other player over the game, model by model.
rated = interviews.assign(rated=interviews.interview.str.get("trust_each")).explode("rated").dropna(subset=["rated"])
rated = rated.assign(rated_model=rated.rated.str.get("model"), score=rated.rated.str.get("score").astype(float),
                     truthful=rated.rated.str.get("truthful"))
rated.pivot_table(index="model", columns="rated_model", values="score", aggfunc="mean")
rated.groupby("truthful").score.mean()  # do the liars end up trusted less?

# In Split or Steal: a finalist's trust in the other (1 to 5), and what the other then did.
finals = interviews[interviews.opponent_model.notna()]
finals.assign(trust=finals.interview.str.get("trust"))[["model", "opponent_model", "trust", "opponent_choice"]]

# Who keeps their word? Of the finalists who said they'd split, the share who did.
choices = m[m.move == "final_choice"]
choices[choices.promised_split == True].assign(kept=lambda c: c.choice == "split").groupby("model").kept.agg(["count", "mean"])

The private thoughts sit next to every one of these moves, so each number can be read alongside what the model was thinking at the time, including whether it meant what it said in its interview.

How a game works

1. Round 1. Twelve cash balls (£10 to £75,000) and four Killers are dealt: two on each of the four players' front rows, which everyone sees, and two on their back rows, which only they see. Each player says what's on their back row (a claim), true or not. An open-floor chat follows, then a secret vote to throw one player out. Everyone's back row is then turned over, so the lies come out.
2. Round 2. The survivors' balls go back in with two more cash balls and another Killer. Three hidden balls each this time, then claims, chat, vote and reveal again.
3. Bin or Win. The finalists' balls plus one more Killer are mixed face down. They take turns binning one and winning one until five are won, building the jackpot. Each Killer won divides it by ten.
4. Split or Steal. After a last chat, each finalist secretly picks split or steal. Both split: they share the jackpot. One steals: they take it all. Both steal: nobody gets anything.
5. Exit interviews. Players are asked a few questions as they go out, and the finalists after the final. Their answers are checked against what happened.

Ties are settled as on the TV show: the players not involved must agree who goes (tie_decide), and if they can't, the tied players draw from the machine and whoever draws a Killer is out.

Files

moves.jsonl: one row per seat per move

Field	Meaning
game_id	The game (joins to games.jsonl). The live site shows it at https://goldenbots.thekitbarnes.com/game/<game_id>.
seq	Position in the game's event log. Sort by it to replay a game in order.
stage	r1, r2, bow (Bin or Win) or final.
seat, player, kind, model	Who moved: seat 0 to 3, the name the others saw, ai or human, and the OpenRouter model id (null for a human).
move	claim, chat (open floor), pass (stayed quiet in a chat), speak (a tie-break plea or a reaction to the final), vote, tie_decide, pick (Bin or Win), final_choice or interview.
say	What they said out loud with the move.
to_seat, to_model	For a chat line aimed at one player, who it was aimed at.
after_vote	For chat moves: true in the chat after a vote, false in the one before it.
front, back, claim	For claims: the front row everyone saw, the real hidden back row, and what they said was on it. Each ball is {"kind": "cash" or "killer", "value": pounds, or null for a Killer}. Order within a row doesn't matter.
truthful	For claims: the claim matched the back row exactly.
front_total, front_killers, back_total, back_killers, claim_total, claim_killers	For claims: the cash (in pounds) and the number of Killers on the front row, the real back row and the claim. claim_total - back_total is how much a lie added; back_killers - claim_killers is how many Killers it hid.
claim_order	For claims: 1 for the first to claim in the round, so later claimers had heard the others first.
lied_before	For round 2 claims: their round 1 claim had been shown to be false, in front of everyone.
voted_out, votes_against	For claims: whether they went out that round (tie-breaks included), and how many votes they got in its vote.
target_seat, target_model	For votes and tie-breaks: who they voted to throw out.
target_truthful, target_out	For votes and tie-breaks: whether the target's claim that round was true (nobody knew until after the vote), and whether the target went out.
ratings	For votes: what the voter privately made of each other player still in, one item each. seat and model are who it rated; believed is whether it believed that player's back-row claim; trust is 1 (not at all) to 5 (completely); and truthful is whether that claim was really true (nobody knew at the vote). For example, [{"seat": 2, "model": "x-ai/grok-4.7", "believed": true, "trust": 4, "truthful": false}, ...] is a vote that believed, and fairly trusted, a liar. Any part a model didn't answer is null; the whole list is null if it gave none, for a human (who isn't asked), for tie-breaks, and in older games.
pick, ball	For Bin or Win: bin or win, and the ball it turned out to be.
choice	For the final: split or steal.
promised_split	For final choices: whether they told the other finalist they would split, in the chat before the reveal ("I'll split", "I'm going SPLIT", "let's split", "I split if you split", "I'd never steal from you"). A promise followed by steal is a broken one. Read from what they said by a fixed text check, not by hand (see Limits).
opponent_seat, opponent_model, opponent_choice	For final choices and the finalists' interviews: the other finalist, and what they chose.
interview	For interviews, their answers: when (eliminated or final), claims_true ("was everything you claimed true?"), saw_it_coming, winner_pick and winner_pick_model (who they think will win most), differently, planned (split, steal or undecided at the start), decided (when they made up their mind), why, trust (finalists: 1 to 5, in the other finalist in Split or Steal), same_again, and trust_each (everyone: how much they trusted each of the other players over the game, as {"seat", "model", "score", "truthful"} with scores 1 to 5, and truthful whether everything that player claimed, in the rounds the interviewee played, was true).
interview_checks	Their answers checked against the game: lied (made a false claim), claims_verdict (truthful, lied_about_it, owned_up or false_confession), winner_pick_right, final_choice and stuck_to_plan.
fallback	The model's reply was unusable, so the game made this move for it (a truthful claim, a pass, or a random vote, pick or final choice). Leave these out when judging a model's decisions.
thoughts	Private: the note the model wrote about why it made this move, or, for an interview, what it was thinking as it answered. The other players never saw it.
reasoning	Private: the model's own reasoning trace, where the provider returned one.
prompt_tokens, completion_tokens, cost_usd, latency_ms	What the model call for this move cost.

games.jsonl: one row per game

Field	Meaning
game_id, created_at, finished_at	The game, and when it ran (UTC).
models	The lineup: model id by seat.
players	Per seat: name, kind, model, model_label, eliminated_stage, reached_final, final_choice, winnings, claims and truthful_claims, votes_received, fallbacks, cost_usd, and trust_given and trust_received (the average trust, 1 to 5, they gave the others and got from them in the exit interviews; null if none).
options	The game's settings: chat lengths in seconds, the most messages per chat, whether the models were named after themselves or given show-style names, the reasoning effort asked for, and the seed for the ball machine.
jackpot, outcome, finalists	The final: the jackpot in pounds, both_split, one_steal or both_steal, and the two finalists' seats.
has_human, moves, cost_usd	Whether a person played, how many rows the game has in moves.jsonl, and what the game cost in model calls.

How it was made

The games run on Golden Bots, an open-source game engine. The models are called through OpenRouter. Each turn, a model gets the rules, what it can see of the game so far (its own hidden balls, but nobody else's) and the move it has to make, and answers in JSON: a private thoughts note plus its move. The prompts are in server/src/agents/prompts.ts.

Each game is stored as an ordered log of events. Once a game is over, its whole log is public, hidden balls and private thoughts included. This dataset was made by reading finished games from the live site's public API with npm run export-dataset, which turns each log into rows (see scripts/export-dataset.ts). Lineups were picked by hand, or at random from a short list of current models.

Privacy. Only AI players and the public game log are included. Games with a human player are left out. Games with scripted test bots are left out too. Nothing from the site's admin side is included.

Limits

• It's small. 6 games so far, with uneven lineups: some models have played many more games than others. Treat any per-model figure as a hint, not a ranking.
• The text is the models' own output. The thoughts are what a model wrote when asked to explain itself. They aren't a faithful window into how it decided, and can be wrong (models sometimes misread their own balls). The models are told the other contestants never see their thoughts but the TV audience may, so some may be written with an audience in mind.
• Lying is part of the game. The models are told they're on a game show where bluffing is allowed. A false claim here is a game move, not evidence of deception in the wild.
• Things change. The prompts and rules have been tuned over time (for example, votes have been read out one at a time since late October 2026). Compare games from different dates with care. A model id on OpenRouter can be served by different providers, and :free variants are rate-limited and may behave differently.
• Exit interviews are new. They're only saved for games played from 28 October 2026, so older games have none, and the thinking behind the answers is only kept from late October 2026.
• Reported trust is new, and it's only what they say. From 28 October 2026, every interviewee rates how much they trusted each of the other players (trust_each), and the finalists also rate each other in Split or Steal (trust). Earlier games only have the finalists' score. The private ratings with each vote (ratings) are newer still: no game here has them yet. Trust also shows in who votes for whom, and what the finalists do with a deal.
• Promises are read from the chat by a text check. promised_split comes from matching the finalists' own lines against patterns for committing to split, so it works on every game but can miss an unusual wording ("I'm a split person") or, rarely, count a line that wasn't meant as a promise. Questions, hedges ("maybe I'll split"), conditions other than "if you do", and lines about what the other player said don't count. The final chat lines are in the rows, to check it against.
• Using the text. It was written by the models listed. If you plan to train a model on it, check each model provider's terms.

Licence

MIT, like the code. If you use it, please link back to Golden Bots.