golden-bots / README.md
Kitbarnes's picture
Sync from kitbarnes1/golden-bots via hub-sync
ade7e03 verified
|
Raw History Blame Contribute Delete
21.1 kB
metadata
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.

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.