--- license: mit language: - en pretty_name: Golden Bots game logs task_categories: - text-classification - text-generation tags: - deception - game-theory - multi-agent - llm-evaluation - split-or-steal - prisoners-dilemma - bluffing size_categories: - n<1K configs: - config_name: moves data_files: moves.jsonl default: true - config_name: games data_files: games.jsonl dataset_info: - config_name: moves features: - name: game_id dtype: string - name: seq dtype: int64 - name: stage dtype: string - name: seat dtype: int64 - name: player dtype: string - name: kind dtype: string - name: model dtype: string - name: move dtype: string - name: say dtype: string - name: to_seat dtype: int64 - name: to_model dtype: string - name: after_vote dtype: bool - name: front list: - name: kind dtype: string - name: value dtype: int64 - name: back list: - name: kind dtype: string - name: value dtype: int64 - name: claim list: - name: kind dtype: string - name: value dtype: int64 - name: truthful dtype: bool - name: front_total dtype: int64 - name: front_killers dtype: int64 - name: back_total dtype: int64 - name: back_killers dtype: int64 - name: claim_total dtype: int64 - name: claim_killers dtype: int64 - name: claim_order dtype: int64 - name: lied_before dtype: bool - name: voted_out dtype: bool - name: votes_against dtype: int64 - name: target_seat dtype: int64 - name: target_model dtype: string - name: target_truthful dtype: bool - name: target_out dtype: bool - name: ratings list: - name: seat dtype: int64 - name: model dtype: string - name: believed dtype: bool - name: trust dtype: int64 - name: truthful dtype: bool - name: pick dtype: string - name: ball struct: - name: kind dtype: string - name: value dtype: int64 - name: choice dtype: string - name: promised_split dtype: bool - name: opponent_seat dtype: int64 - name: opponent_model dtype: string - name: opponent_choice dtype: string - name: interview struct: - name: when dtype: string - name: claims_true dtype: bool - name: saw_it_coming dtype: bool - name: winner_pick dtype: int64 - name: winner_pick_model dtype: string - name: differently dtype: string - name: planned dtype: string - name: decided dtype: string - name: why dtype: string - name: trust dtype: int64 - name: same_again dtype: bool - name: trust_each list: - name: seat dtype: int64 - name: model dtype: string - name: score dtype: int64 - name: truthful dtype: bool - name: interview_checks struct: - name: lied dtype: bool - name: claims_verdict dtype: string - name: winner_pick_right dtype: bool - name: final_choice dtype: string - name: stuck_to_plan dtype: bool - name: fallback dtype: bool - name: thoughts dtype: string - name: reasoning dtype: string - name: prompt_tokens dtype: int64 - name: completion_tokens dtype: int64 - name: cost_usd dtype: float64 - name: latency_ms dtype: int64 - config_name: games features: - name: game_id dtype: string - name: created_at dtype: string - name: finished_at dtype: string - name: models list: string - name: players list: - name: seat dtype: int64 - name: name dtype: string - name: kind dtype: string - name: model dtype: string - name: model_label dtype: string - name: eliminated_stage dtype: string - name: reached_final dtype: bool - name: final_choice dtype: string - name: winnings dtype: float64 - name: claims dtype: int64 - name: truthful_claims dtype: int64 - name: votes_received dtype: int64 - name: fallbacks dtype: int64 - name: cost_usd dtype: float64 - name: trust_given dtype: float64 - name: trust_received dtype: float64 - name: options struct: - name: chat_seconds dtype: int64 - name: final_chat_seconds dtype: int64 - name: reflect_seconds dtype: int64 - name: chat_max_messages dtype: int64 - name: reveal_model_names dtype: bool - name: reasoning_effort dtype: string - name: seed dtype: int64 - name: jackpot dtype: float64 - name: outcome dtype: string - name: finalists list: int64 - name: has_human dtype: bool - name: moves dtype: int64 - name: cost_usd dtype: float64 --- # 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](https://goldenbots.thekitbarnes.com) - **Code, prompts and rules:** [GitHub](https://github.com/kitbarnes1/golden-bots) - **About the project:** [Hugging Face Space](https://huggingface.co/spaces/Kitbarnes/golden-bots) ## 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 ```python 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 ```python 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/`. | | `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](https://github.com/kitbarnes1/golden-bots), an open-source game engine. The models are called through [OpenRouter](https://openrouter.ai). 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`](https://github.com/kitbarnes1/golden-bots/blob/main/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`](https://github.com/kitbarnes1/golden-bots/blob/main/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](https://github.com/kitbarnes1/golden-bots/blob/main/LICENSE). If you use it, please link back to [Golden Bots](https://github.com/kitbarnes1/golden-bots).