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
---
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/<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](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).