Dataset Card for BotzoneBenchDataset

Dataset Description

Dataset Summary

BotzoneBenchDataset is a structured JSONL version of the raw evaluation logs released with BotzoneBench, an anchored evaluation framework for large language models in multi-game decision-making settings.

This dataset separates two complementary views of the same benchmark:

1. llm_single and llm_tournament: turn-level LLM interaction records containing prompts, optional reasoning traces, model outputs, parsed responses, and stable identifiers.
2. game_single and game_tournament: full game-process records containing serialized environment events for the same matches.

The processed format is designed for:

• reasoning trace analysis,
• action prediction and imitation learning,
• strategic trajectory analysis,
• error analysis and replay,
• alignment between natural language reasoning and environment actions.

The four released configurations are:

Config	Description	Records
llm_single	LLM-vs-baseline turn records	174,737
llm_tournament	LLM-vs-LLM turn records	2,372
game_single	Full game event logs for anchored evaluation	424,319
game_tournament	Full game event logs for LLM tournaments	2,409

Total records across all configurations: 881,216.

Supported Tasks and Leaderboards

This dataset is intended for research and benchmarking rather than for a single official leaderboard.

Potential task formulations include:

• next-action prediction from structured prompts,
• reasoning-to-action consistency analysis,
• strategic planning and long-horizon decision modeling,
• cross-game transfer learning,
• alignment of textual reasoning with environment event streams.

There is no official leaderboard attached to this processed release.

Languages

The dataset is primarily in English, with a smaller amount of Chinese text in some Mahjong-related prompts, metadata strings, and action representations. For this reason, the dataset is marked as multilingual (en, zh).

Dataset Structure

Data Instances

llm_* configurations store one record per model decision attempt. A simplified example:

{
  "id": "TexasHoldem2p-lv2-gemini-3-pro-preview-24-seat-0-decision-00001",
  "dataset_kind": "llm_single",
  "match_key": "TexasHoldem2p-lv2-gemini-3-pro-preview-24",
  "game": "TexasHoldem2p",
  "level": "lv2",
  "llm_name": "gemini-3-pro-preview",
  "round": "24",
  "seat": 0,
  "decision_index": 1,
  "system_prompt": "...",
  "user_prompt": "...",
  "reasoning": "...",
  "output": "...",
  "response": 0,
  "game_event_index": 1,
  "game_event_id": "TexasHoldem2p-lv2-gemini-3-pro-preview-24-event-00001"
}

game_* configurations store one record per serialized environment event. A simplified example:

{
  "id": "Reversi-ClaudeSonnet4.5-vs-DeepSeek3.2-0-event-00002",
  "dataset_kind": "game_tournament",
  "match_key": "Reversi-ClaudeSonnet4.5-vs-DeepSeek3.2-0",
  "game": "Reversi",
  "round": "0",
  "event_index": 2,
  "actor_seat": 0,
  "payload": {
    "x": 2,
    "y": 3,
    "player": 0
  }
}

Data Fields

The dataset uses a shared core schema plus configuration-specific fields.

Common fields across all configurations:

Field	Description
id	Stable unique identifier for the current record.
dataset_kind	One of llm_single, llm_tournament, game_single, game_tournament.
mode	single or tournament.
match_key	Stable cross-file linkage key for a match.
game	Game name, such as Reversi, Gomoku, TexasHoldem2p, ChineseStandardMahjong.
round	Match round identifier extracted from filenames.
log_path	Relative path of the original source log file.
is_rematch	Whether the source file belongs to a rematch naming pattern.

Key fields in llm_* configurations:

Field	Description
level	Baseline difficulty level for single-mode records; null for tournaments.
llm_name	Name of the acting LLM for this record.
opponent_name	Opponent model name or baseline.
seat	Player seat extracted from the raw log filename.
decision_index	Sequential index of the model decision attempt within a single LLM log file.
timestamp	Timestamp prefix recorded by the logger.
system_prompt	System prompt sent to the model when available.
user_prompt	User prompt or game-state prompt when available.
reasoning	Model reasoning trace if present; may be empty or null.
output	Raw natural-language action proposal or formatted answer.
response	Parsed action returned to the environment. Can be a dict, string, number, or null.
raw_debug	Original raw debug blob from the source log.
raw_response	Original raw response line from the source log.
game_log_path	Relative path to the corresponding full game log when resolvable.
game_log_stem	Canonical game-log stem derived from the filename.
game_event_index	Linked event index in the corresponding game_* dataset when alignment is available.
game_event_id	Linked event record ID in the corresponding game_* dataset when alignment is available.

Additional fields in llm_single:

Field	Description
game_starter	Whether the match filename indicates llm first or bl first.

Additional fields in llm_tournament:

Field	Description
llm1_name	First LLM name parsed from the tournament filename.
llm2_name	Second LLM name parsed from the tournament filename.

Key fields in game_* configurations:

Field	Description
event_index	Sequential index of the serialized event within a game log.
actor_seat	Seat inferred from the event payload when possible.
event_type	Event type derived from the payload, if available.
payload	Raw environment event object or primitive payload from the game log.

Additional fields in game_single:

Field	Description
level	Baseline difficulty level.
llm_name	Evaluated LLM name.
game_starter	Whether the single-game filename indicates llm first or bl first.

Additional fields in game_tournament:

Field	Description
llm1_name	First tournament model name.
llm2_name	Second tournament model name.

Notes on identifiers and linking:

• id is designed to be stable and unique within the processed release.
• match_key is the primary bridge between LLM logs and full game logs.
• game_event_id provides a finer-grained bridge when an LLM decision can be aligned to a specific game event.
• Some passive or infrastructure-level records, such as PASS in multi-player games, may not have a game_event_id.

Data Splits

Each configuration currently exposes a single train split containing the full processed file:

Config	Split	File
llm_single	train	llm_single_records.jsonl
llm_tournament	train	llm_tournament_records.jsonl
game_single	train	game_single_records.jsonl
game_tournament	train	game_tournament_records.jsonl

If this dataset is uploaded to the Hugging Face Hub, it can be loaded with configuration names similar to: from datasets import load_dataset

llm_single = load_dataset("BotzoneBenchDataset", "llm_single")
game_single = load_dataset("BotzoneBenchDataset", "game_single")

Dataset Creation

Curation Rationale

The raw BotzoneBench logs were originally collected for evaluating LLM strategic behavior under anchored and tournament-based game settings. The purpose of this processed release is to make the logs easier to consume in downstream pipelines by:

• converting heterogeneous raw logs into line-delimited JSON,
• preserving prompt and reasoning traces,
• preserving full environment event streams,
• adding stable identifiers and cross-references,
• separating turn-level language traces from full-game trajectories.

Source Data

Initial Data Collection and Normalization

The processed dataset was derived from the following raw directories in the BotzoneBench repository:

• log_llm_records
• log_llm_tournament_records
• log_game_records
• log_game_tournament_records

The normalization process:

1. parsed turn-level Debug and Response log lines into structured records,
2. parsed full game logs stored as serialized JSON arrays,
3. assigned stable record IDs,
4. derived match_key values from directory structure and filename conventions,
5. linked decision records to game-process records whenever a reliable alignment was available.

The processing script used for this release is convert_logs_to_jsonl.py in the source repository.

Who are the source language producers

There are multiple language-producing sources in this dataset:

• prompt templates authored by the BotzoneBench / Botzone-ALE codebase,
• game-state renderers implemented in the environment wrappers,
• model-generated reasoning and outputs from evaluated LLMs,
• structured action strings and event payloads emitted by the game environments.

Human free-form annotations were not added manually during this processing stage.

Annotations

Annotation process

This release does not introduce a separate manual annotation layer.

The labels and structured signals in the dataset are programmatically derived from:

• raw LLM interaction logs,
• parsed environment responses,
• serialized game engine events,
• file and directory naming conventions.

Fields such as response, actor_seat, game_starter, llm1_name, llm2_name, and game_event_id are extracted or inferred during preprocessing.

Who are the annotators

There are no dedicated human annotators for this processed release. Supervision signals come from the benchmark software stack and the evaluated models themselves.

Considerations for Using the Data

Social Impact of Dataset

This dataset may be useful for research on:

• LLM strategic reasoning,
• interpretability of action selection,
• benchmarking under controlled opponents,
• multi-game evaluation beyond standard NLP tasks.

It may also help researchers study failure modes in sequential decision-making systems, especially where natural-language reasoning diverges from the final action.

Discussion of Biases

Several biases should be considered:

• Game selection bias: the benchmark covers a specific set of board and card games rather than the full range of real-world decision tasks.
• Prompt design bias: prompts are generated by the benchmark framework and may privilege some styles of explanation or action formatting.
• Model coverage bias: the released logs reflect a finite set of LLMs, baselines, and levels used during collection.
• Language bias: most prompts are in English, with only limited Chinese coverage.
• Logging bias: some games expose richer intermediate state than others, which can affect apparent reasoning quality.

Other Known Limitations

Known limitations include:

• Not every record contains an explicit reasoning trace; reasoning may be empty or null.
• Some multi-player logs contain passive records such as PASS, which are useful for replay but may not correspond to a distinct game action by the target model.
• game_event_id is best-effort and intentionally left empty when alignment would be unreliable.
• Schema details vary across games because action spaces differ substantially.
• The dataset contains model-generated text that may be incorrect, hallucinated, strategically weak, or internally inconsistent.

Users should validate subset-specific assumptions before training models that rely on uniform field semantics across all games.

Additional Information

Dataset Curators

This processed release was generated from the BotzoneBench repository and its associated raw benchmark logs.

Licensing Information

This processed dataset card declares the dataset license as Creative Commons Attribution 4.0 (cc-by-4.0).

Citation Information

If you use this processed dataset, please cite the source repository and indicate that you used the JSONL-normalized release. A repository-style citation can be used as a starting point:

@misc{botzonebench_processed_2026,
  title        = {BotzoneBenchDataset},
  author       = {BotzoneBench Contributors},
  year         = {2026},
  howpublished = {\url{https://github.com/AMysteriousBeing/BotzoneBench}},
  note         = {Processed JSONL release derived from BotzoneBench raw evaluation logs}
}

Contributions

Thanks to the BotzoneBench and Botzone-ALE contributors for the benchmark framework, raw log generation, and game environment infrastructure, and to the Hugging Face datasets documentation for the dataset card structure used in this release.