Datasets:

vanyacohen
/

MET-Bench-Shell

license: mit
pretty_name: MET-Bench Shell Game
language:
  - en
tags:
  - multimodal
  - entity-tracking
  - reasoning
  - synthetic
  - rlvr
size_categories:
  - 10K<n<100K
configs:
  - config_name: full
    default: true
    data_files:
      - split: train
        path: full-train.parquet
      - split: validation
        path: full-validation.parquet
      - split: test
        path: full-test.parquet
  - config_name: evaluation
    data_files:
      - split: test
        path: evaluation-test.parquet
  - config_name: evaluation_text_only
    data_files:
      - split: test
        path: evaluation-text-test.parquet

MET-Bench: Multimodal Entity Tracking for Evaluating the Limitations of Vision-Language and Reasoning Models

Vanya Cohen and Raymond Mooney · ICML 2026

Paper · Publication page · Load the dataset · Citation

Domains: Chess · Shell Game · Minecraft

MET-Bench evaluates entity state tracking across text and image modalities. This repository contains the Shell Game domain.

Shell Game

A ball is placed under one of three shells. The shells are swapped pairwise, and the goal is to track the ball's position through the sequence of swaps. The model receives the initial ball position and the actions, then predicts which shell contains the ball after the final swap.

Parallel text and image modalities

Each trajectory has two parallel action sequences: text-encoded actions in actions and image-encoded actions in image_actions. The entries actions[i] and image_actions[i] describe the same swap at the same step. Either sequence, together with the initial ball position, provides the information needed to solve the task.

Representation	Field	Contents
Text	`actions`	Ordered text descriptions of the swaps.
Image	`image_actions`	Images depicting the same swaps in the same order.

Both representations are stored together in each row and share the same initial_state, states, and final_state. Ball positions are integers from 1 to 3.

Shell positions are numbered 1–3. A text action such as 1 swap 2 exchanges the contents of positions 1 and 2. In the corresponding image, green labels identify the two shells being swapped, while the ball remains hidden. The three possible pairs of positions correspond to three swap images.

Dataset splits

We simulate repeated shell swaps to generate 56,000 trajectories, each containing 100 actions. Each trajectory includes the initial ball position, text and image representations of the actions, and the ground-truth ball position after every swap.

Configuration	Actions per example	Train	Validation	Test
`full` (default)	100	50,000	1,000	5,000

This release contains the full trajectories. The paper’s experiments use a subset of the data, deduplicated at the evaluated action-sequence length. The complete 100-action trajectories are disjoint across the released splits; shorter prefixes can be shared across splits.

Evaluation subset

The evaluation configuration contains a single 500-example test split for benchmark evaluation. Examples are the first 500 unique (initial_state, actions[:10]) inputs in the full test split, in source order. Each example contains ten actions, ten aligned action images, and eleven states; final_state is the state after the tenth action.

The evaluation_text_only configuration contains the same examples in the same order, with image fields omitted for text-only evaluation. Both configurations preserve the source example_id values and all text fields. The full configuration remains the default.

from datasets import load_dataset

test = load_dataset("vanyacohen/MET-Bench-Shell", "evaluation", split="test")
text_test = load_dataset("vanyacohen/MET-Bench-Shell", "evaluation_text_only", split="test")

Evaluate with lmms-eval

Run the complete MET-Bench evaluation across Minecraft, Chess, and Shell Game, with separate text and image tasks, using lmms-eval. Each task evaluates 500 examples. Chess and Shell Game use ten-action sequences; Minecraft uses next-state prediction tasks.

Install the current version from GitHub:

python -m pip install -U git+https://github.com/EvolvingLMMs-Lab/lmms-eval.git

For an OpenAI-compatible API, set OPENAI_API_KEY in your environment and run:

python -m lmms_eval \
  --model openai \
  --model_args model_version=gpt-4o-mini \
  --tasks metbench \
  --batch_size 1 \
  --log_samples \
  --output_path results/metbench

Replace gpt-4o-mini with your model ID. For another compatible provider, also set OPENAI_API_BASE. The complete evaluation requires a model that supports text and multiple images. Results and sample outputs are saved to results/metbench.

See the MET-Bench task documentation for task names and additional options.

Usage

from datasets import load_dataset

dataset = load_dataset("vanyacohen/MET-Bench-Shell", "full")
example = dataset["test"][0]

initial_state = example["initial_state"]
text_actions = example["actions"]
image_actions = example["image_actions"]  # decoded PIL images
target = example["final_state"]

final_state contains the target ball position. states contains the complete sequence of ball positions, including the initial state.

Data fields

The dataset is stored as Parquet files with text actions and embedded images in each row.

Field	Type	Description
`example_id`	string	Stable identifier for the split and row.
`initial_state`	int64	Initial ball position, numbered 1–3.
`actions`	list of strings	Ordered swaps, e.g. `1 swap 2`.
`image_actions`	list of Image	One embedded 400×400 PNG per swap, aligned with `actions`.
`states`	list of int64	Initial ball position followed by the position after each swap.
`final_state`	int64	Ball position after the final swap.

Rows in full contain 100 text actions, 100 images, and 101 states. Rows in evaluation contain 10 text actions, 10 images, and 11 states. Action i, represented by both actions[i] and image_actions[i], takes the ball from states[i] to states[i + 1]. The first state equals initial_state, and the last state equals final_state.

For illustration, a two-action trajectory starting at position 1 has:

initial_state = 1
actions = ["1 swap 2", "2 swap 3"]
states = [1, 2, 3]
final_state = 3

Its two images depict the same swaps in the same order. The released trajectories follow this structure with 100 actions in full and 10 actions in evaluation.

Citation

@inproceedings{cohen2026metbench,
  title={MET-Bench: Multimodal Entity Tracking for Evaluating the Limitations of Vision-Language and Reasoning Models},
  author={Cohen, Vanya and Mooney, Raymond},
  booktitle={International Conference on Machine Learning},
  year={2026},
  url={https://arxiv.org/abs/2502.10886}
}

License

MIT.