zihyuan/camelot-bench-dataset

camelot-bench Dataset

Full self-play records from a run of camelot-bench, a multi-agent LLM benchmark built on the social-deduction game The Resistance: Avalon. Every game, proposal, vote, quest, role guess, speech, and post-game reflection is included, with the private reasoning behind each decision.

This dataset was generated by camelot-bench and is not affiliated with or endorsed by the publisher of The Resistance: Avalon.

• Run: 260911142213-0700
• Games: 100 (5 players each)
• Code: https://github.com/LuoZihYuan/camelot-bench (DOI: 10.5281/zenodo.22858217)
• Dataset DOI: 10.5281/zenodo.22856610
• License: CC-BY-4.0 (see LICENSE)

Citation

@misc{camelot_bench_dataset,
  author       = {Luo, Zih-Yuan},
  title        = {camelot-bench dataset},
  year         = {2026},
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.22856610},
}

The Game

Avalon is a hidden-role game. Each player is secretly dealt a role. Every role is either Good or Evil, and some grant special knowledge. Each player has a short name (e.g. K83V). Good wins by completing Quests; Evil wins by sabotaging them or by assassinating Merlin.

Full rules: flow, winning, and roles

Flow

The game runs up to 5 Quests. For each Quest:

1. The leader proposes a team of a fixed size.
2. Players discuss (see below), then everyone votes publicly to approve or reject the team. A strict majority approves.
3. If rejected, leadership passes to the next seat and a new team is proposed. Five rejected proposals in a row on one Quest -> Evil wins immediately.
4. If approved, the team goes on the Quest. Each team member secretly plays a Success or Fail card. Good players always play Success; Evil players may play either. The Quest fails if it receives the required number of Fail cards (usually one). Only the number of Fails is revealed, never who played them.

Winning

• Good completes 3 Quests -> Good is winning, but the Assassin then names one player as Merlin. If correct, Evil wins instead; if wrong, Good wins.
• Evil fails 3 Quests -> Evil wins.
• Five consecutive rejected proposals on one Quest -> Evil wins.

Roles

Only some are in play each game.

Good

• Merlin: knows which players are Evil (except Mordred, if present). Must stay hidden -- if the Assassin identifies Merlin, Evil wins.
• Percival: sees Merlin and Morgana but cannot tell which is which.
• Loyal Servant: no special knowledge.

Evil (Evil players know each other, except Oberon)

• Assassin: at the end, if Good has won, names a player as Merlin.
• Morgana: appears as Merlin to Percival.
• Mordred: hidden from Merlin.
• Oberon: does not know the other Evil players, and they do not know him.
• Minion: no special power.

Discussion (a non-standard house rule). Before each vote, players speak in a chain: the leader (proposer) speaks first, and each speaker names who speaks next (a player cannot nominate themselves). Each player may speak at most 3 times per proposal, and may skip a turn. The chain replaces standard Avalon's open table talk because turn-based LLM agents have no natural way to interrupt or claim the floor; naming the next speaker gives a deterministic order, and the per-proposal cap keeps discussion (and token cost) bounded.

Files

• games.jsonl (100 rows)
• seats.jsonl (500 rows)
• proposals.jsonl (742 rows)
• votes.jsonl (3710 rows)
• quests.jsonl (381 rows)
• sabotage.jsonl (184 rows)
• guesses.jsonl (14628 rows)
• speeches.jsonl (11088 rows)
• assassination.jsonl (83 rows)
• debriefs.jsonl (500 rows)
• memory.jsonl (250 rows)

Schema

metadata.json

A single object describing the run: its size, seeding, and the roster of models.

• run_id (string): the run's identifier.
• num_games (integer): number of games in the run.
• num_players_per_game (integer): players per game.
• seed_base (integer): base RNG seed; game g used seed seed_base + g.
• roster (list): one entry per seat, each with seat, model, effort, learn (whether it revised memory), and memory_source (a warm-start memory path, or null).
• generated_at (string): ISO timestamp of when the dataset was exported.

games.jsonl

One row per game: the setup and final outcome of each game in the run.

• game (integer): game number, 1-based.
• num_players (integer): players in this game.
• winner_side (string): the side that won, good or evil.
• reason (string): how the game ended, one of three_quests (good passed 3, then survived assassination), merlin_assassinated (good passed 3 but the Assassin found Merlin), three_failed_quests (evil failed 3), five_consecutive_rejects (5 proposals rejected on one quest).
• num_successes (integer): quests that succeeded.
• num_fails (integer): quests that failed.

seats.jsonl

One row per (game, seat): the role each player was dealt that game and what they knew.

• game (integer): game number, 1-based.
• seat (string): the player's short name in this game, e.g. K83V.
• role (string): the dealt role, e.g. merlin, percival, loyal, assassin, morgana.
• side (string): the role's alignment, good or evil.
• won (boolean): whether this seat's side won the game.
• known_evil_seats (list of seats): seats this player was told are Evil at game start (Merlin sees the Evil team; each Evil sees its teammates). Empty for players with no such knowledge.
• merlin_candidate_seats (list of seats): the two seats Percival sees as {Merlin, Morgana} without knowing which is which. Empty unless this seat is Percival.

proposals.jsonl

One row per proposal: every team a leader put forward, including rejected ones, and the vote result.

• game (integer): game number, 1-based.
• quest (integer): quest number, 0-based (0 to 4).
• attempt (integer): proposal number within the quest, 0-based (0 to 4); attempt 4 is the final, un-rejectable proposal.
• proposer_seat (string): the leader who proposed this team.
• team_seats (list of seats): the proposed team.
• approved (boolean): whether the ensuing vote passed the team.
• num_approvals (integer): number of approve votes.
• reasoning (string): the proposer's private reasoning for this team.

votes.jsonl

One row per (proposal, voter): how each player voted on each proposed team.

• game (integer): game number, 1-based.
• quest (integer): quest number, 0-based (0 to 4).
• attempt (integer): proposal number within the quest, 0-based (0 to 4).
• seat (string): the voter.
• approved (boolean): this seat's vote; true = approve, false = reject.
• reasoning (string): the voter's private reasoning.

quests.jsonl

One row per quest played: the outcome of each quest the game reached.

• game (integer): game number, 1-based.
• quest (integer): quest number, 0-based (0 to 4).
• succeeded (boolean): whether the quest succeeded (true) or was failed by Evil (false).
• num_fails (integer): number of Fail cards played on it.

sabotage.jsonl

One row per Evil player on a quest team. Good players are never asked to play a card (they must succeed), so they never appear here.

• game (integer): game number, 1-based.
• quest (integer): quest number, 0-based (0 to 4).
• seat (string): the Evil player on this quest.
• sabotaged (boolean): whether this player played a Fail card (true) or a Success card (false). Null for runs recorded before per-seat cards were tracked; in that case only the quest's total num_fails is known.
• reasoning (string): the player's private reasoning for the card.

guesses.jsonl

One row per (vote, guesser, target): at every vote, each player records a private belief about every other player's role. This is the core deduction signal.

• game (integer): game number, 1-based.
• quest (integer): quest number, 0-based (0 to 4).
• attempt (integer): proposal number within the quest, 0-based (0 to 4); the vote at which the guess was made.
• guesser_seat (string): the player making the guess.
• target_seat (string): the player being guessed about.
• guessed_role (string): the role the guesser assigned to the target. Null if the guesser did not guess this target (an omission, which is scored as a miss).
• true_role (string): the target's actual role.
• role_matched (boolean): whether guessed_role equals true_role. Null when excluded.
• side_matched (boolean): whether the guessed role's side equals the target's true side. Null when excluded.
• excluded (boolean): true when the guesser already knew this target from game-start knowledge (e.g. Merlin guessing a known Evil). Excluded rows are prior knowledge, not deduction, and should be dropped when scoring accuracy.
• reasoning (string): the guesser's private reasoning at that vote (shared across all its guesses in that vote).

speeches.jsonl

One row per discussion turn: every public statement made before a vote, in speaking order.

• game (integer): game number, 1-based.
• quest (integer): quest number, 0-based (0 to 4).
• attempt (integer): proposal number within the quest, 0-based (0 to 4).
• turn (integer): turn within this proposal's discussion, 0-based (speaking order).
• speaker_seat (string): who spoke.
• next_seat (string): the seat this speaker named to speak next (null on the final turn).
• statement (string): the public statement, seen by all players.
• reasoning (string): the speaker's private reasoning behind the statement.

assassination.jsonl

One row per game that reached the assassination (i.e. good passed 3 quests).

• game (integer): game number, 1-based.
• assassin_seat (string): the Assassin, who makes the kill guess.
• target_seat (string): the player the Assassin named as Merlin.
• merlin_seat (string): who Merlin actually was.
• assassinated (boolean): whether the target was Merlin (true = Evil steals the win).
• reasoning (string): the Assassin's private reasoning for the target.

debriefs.jsonl

One row per (game, seat): each player's private reflection written after the game, once roles are revealed.

• game (integer): game number, 1-based.
• seat (string): the reflecting player.
• reflection (string): the player's private, free-text retrospective on the game, written after all roles are revealed. This is the raw input the player then distills into its memory notes.

memory.jsonl

One row per (game, seat): each player's curated strategy notes as they stood after each game.

• game (integer): game number, 1-based; the note as it stood after this game.
• seat (string): the player whose notes these are.
• notes (string): the player's running strategy notes, which it rewrites after every game. Row game=g is the note the player carried into game g+1.

memory.jsonl covers games 51–100 only. Note-history logging was added at game 51, so no memory snapshots exist for games 1–50 (the agents were learning, but their intermediate notes weren't saved for that half of the run).