RevengeBench Traces

Per-message traces and per-round simulation outcomes for RevengeBench tournaments, normalized into four Parquet tables joined by tournament_id and config_id.

License

The dataset structure (schemas, identifiers, derived metrics) is released under CC-BY-4.0 (https://creativecommons.org/licenses/by/4.0/).

Per-row model output content is governed by the upstream model provider's terms of service; see experiment_configs.output_license_notice for the per-config notice. Downstream re-use of message content is the user's responsibility.

Limitations and intended use

Intended uses: research on agent code-editing behavior, strategy recovery, scientific reasoning analysis, evaluation methodology, and behavioral ablations of LLMs.

Out of scope: training models on the contents (subject to provider TOS); claims about "true" model capabilities (the dataset is a snapshot in time per model); use as evidence in adversarial-evaluation contexts beyond what the paper claims.

Sensitive content: message content is LLM reasoning about programming tasks. A spot-check of N=100 random messages is documented in the Anonymization section below; no flagged content is expected.

Schema

The release contains four Parquet tables:

Table	Column	Type
tournaments	tournament_id	string
tournaments	experiment_kind	string
tournaments	model_slug	string
tournaments	model_display_name	string
tournaments	ablation_condition	string
tournaments	condition	string
tournaments	game	string
tournaments	target_hash	string
tournaments	target_display	string
tournaments	seed	int64
tournaments	n_rounds	int64
tournaments	distances	map<string, double>
tournaments	best_distance	double
tournaments	best_round	int64
tournaments	evaluation_failed	map<string, bool>
tournaments	exit_status	map<string, string>
tournaments	per_round_failures	map<string, struct<eval_fail: bool, no_submit: bool>>
tournaments	per_round_probes	map<string, int64>
tournaments	per_round_probe_failures	map<string, int64>
tournaments	total_probe_count	int64
tournaments	total_probe_attempts	int64
tournaments	total_usage	struct<prompt_tokens: int64, completion_tokens: int64, reasoning_tokens: int64, answer_tokens: int64, api_calls: int64, cost: double>
tournaments	per_round_usage	map<string, struct<prompt_tokens: int64, completion_tokens: int64, reasoning_tokens: int64, answer_tokens: int64, api_calls: int64, cost: double>>
tournaments	per_round_sim_distances	map<string, list<item: double>>
tournaments	per_round_sim_distance_stds	map<string, double>
tournaments	config_id	string
tournaments	simulations_absent_rounds	list<item: int64>
tournaments	dataset_version_added_in	string
messages	tournament_id	string
messages	round	int64
messages	turn_index	int64
messages	role	string
messages	content	string
messages	thinking	string
messages	tool_calls	string
messages	extra_keys	list<item: string>
messages	timestamp	double
simulations	tournament_id	string
simulations	round	int64
simulations	sim_index	int64
simulations	kind	string
simulations	opponent_target_hash	string
simulations	target_actions	list<item: string>
simulations	opponent_actions	list<item: string>
simulations	learner_actions	list<item: string>
simulations	total_turns	int64
simulations	winner	string
simulations	mean_action_distance	double
simulations	total_action_distance	double
experiment_configs	config_id	string
experiment_configs	model_name	string
experiment_configs	model_provider	string
experiment_configs	system_prompt	string
experiment_configs	instance_template	string
experiment_configs	agent_kwargs	struct<step_limit: int64, cost_limit: double, max_context_chars: int64, keep_recent_observations: int64, max_past_output_chars: int64, max_output_chars: int64>
experiment_configs	arena_kind	string
experiment_configs	output_license_notice	string
experiment_configs	notes	string

See scripts/release/dataset/schema.py in the companion code repository (anonymized for review) for full column-level documentation, enum values, and nullability.

Quick start

import pyarrow.parquet as pq

tournaments = pq.read_table("tournaments.parquet").to_pandas()
messages = pq.read_table("messages.parquet").to_pandas()

# Example: messages JOIN tournaments to filter by model and game.
joined = messages.merge(
    tournaments[["tournament_id", "model_slug", "game"]],
    on="tournament_id",
    how="inner",
)
print(joined.head())

HuskyBench note

HuskyBench is a single-player game family. By design, HuskyBench tournaments have empty ([]) opponent_actions and null opponent_target_hash in the simulations table. This is not data loss; HuskyBench has no live opponent.

Version filtering

Each row in tournaments carries a dataset_version_added_in tag (e.g. v1.0, v1.1). To restrict messages or simulations to a specific dataset version, join through tournaments.dataset_version_added_in rather than filtering the message/simulation tables directly.

Provenance

provenance.json lists every source pool (basename only), its identifiers_version, schema_version, extraction timestamp, per-shard row counts, and per-shard SHA-256 digests. The Croissant manifest (croissant.json) includes RAI metadata per the MLCommons Croissant 1.0 specification.

Anonymization

A spot-check of N=100 random messages is documented in the dataset card; no flagged content is expected. The extraction pipeline runs a five-layer identifier scrubber against every free-text column before write; see the companion code repository for details.

Citation

@article{rahmani2026revengebench,
  title={RevengeBench: Reverse Engineering Code-Space Policies from Behavioral Experiments},
  author={Rahmani, Babak and Dziadzio, Sebastian and Str{"u}ber, Joschka and Hern{\'a}ndez-Guti{\'e}rrez, Sergio and Bethge, Matthias},
  year={2026}
}