Datasets:

rahmanidashti
/

StepBench

pretty_name: StepBench
language:
  - en
license: apache-2.0
tags:
  - benchmark
  - task-understanding
  - procedural-reasoning
  - planning
configs:
  - config_name: task1_last_step_selection
    data_files:
      - split: test
        path: data/test/task1_last_step_selection.json
      - split: validation
        path: data/validation/task1_last_step_selection.json
  - config_name: task2_missing_step_recovery
    data_files:
      - split: test
        path: data/test/task2_missing_step_recovery.json
      - split: validation
        path: data/validation/task2_missing_step_recovery.json
  - config_name: task3_incorrect_step_detection
    data_files:
      - split: test
        path: data/test/task3_incorrect_step_detection.json
      - split: validation
        path: data/validation/task3_incorrect_step_detection.json
  - config_name: task4_step_reordering
    data_files:
      - split: test
        path: data/test/task4_step_reordering.json
      - split: validation
        path: data/validation/task4_step_reordering.json
  - config_name: task5_next_step_generation
    data_files:
      - split: test
        path: data/test/task5_next_step_generation.json
      - split: validation
        path: data/validation/task5_next_step_generation.json
  - config_name: task6_full_plan_generation
    data_files:
      - split: test
        path: data/test/task6_full_plan_generation.json
      - split: validation
        path: data/validation/task6_full_plan_generation.json

StepBench

StepBench evaluates language models' ability to understand and generate ordered procedures for everyday tasks. It contains six evaluation tasks built from wikiHow procedures, covering step selection, error detection, ordering, and generation.

The main reference corpus contains 6,885 procedures, 30,975 steps, and 2,922 source articles across 81 categories. StepBench-Val is a separate corpus of 214 procedures and 1,034 steps, derived from 94 source articles created in 2026, across 27 of the main corpus's categories.

Tasks and splits

Each task is a separate Hugging Face configuration with two splits:

test: the main StepBench evaluation set.
validation: StepBench-Val, the separate 2026 evaluation set. It is not a random development split of the main benchmark and is excluded from the main benchmark's headline results.

There is no training split.

Task	Configuration	Evaluation objective	Test examples	Validation examples
T1	`task1_last_step_selection`	Select the missing final step from four options.	6,885	214
T2	`task2_missing_step_recovery`	Select a missing step at any position from four options.	6,885	214
T3	`task3_incorrect_step_detection`	Identify the position of a substituted incorrect step.	6,866	214
T4	`task4_step_reordering`	Recover the correct order of shuffled steps.	6,932	214
T5	`task5_next_step_generation`	Generate the next step given a procedure prefix.	6,819	214
T6	`task6_full_plan_generation`	Generate an entire ordered plan from its task query.	6,885	214

Repository structure

StepBench/
├── README.md
└── data/
    ├── test/
    │   ├── task1_last_step_selection.json
    │   ├── task2_missing_step_recovery.json
    │   ├── task3_incorrect_step_detection.json
    │   ├── task4_step_reordering.json
    │   ├── task5_next_step_generation.json
    │   └── task6_full_plan_generation.json
    └── validation/
        ├── task1_last_step_selection.json
        ├── task2_missing_step_recovery.json
        ├── task3_incorrect_step_detection.json
        ├── task4_step_reordering.json
        ├── task5_next_step_generation.json
        └── task6_full_plan_generation.json

Each JSON file contains a top-level array of example objects. Nested fields retain their JSON structure, including lists of steps and answer objects.

Loading the dataset

Install the Hugging Face Datasets library:

pip install datasets

Load one task and split:

from datasets import load_dataset

test = load_dataset(
    "rahmanidashti/StepBench",
    "task1_last_step_selection",
    split="test",
)

validation = load_dataset(
    "rahmanidashti/StepBench",
    "task1_last_step_selection",
    split="validation",
)

Load both splits of a task:

plans = load_dataset(
    "rahmanidashti/StepBench",
    "task6_full_plan_generation",
)

print(plans["test"][0]["method_title"])
print(plans["validation"][0]["method_title"])

Data fields

Shared fields

Field	JSON type	Description
`id`	Integer	Procedure identifier within a corpus. IDs are shared across task variants where the procedure is present.
`title`	String	Original source article title.
`method_title`	String	Procedure-specific task query used in model prompts.
`category`	String	Source category, using the main benchmark's category taxonomy.
`steps`	Array	Full reference steps for T1, T2, T5, and T6; the modified sequence for T3; the shuffled sequence for T4.

For T1, T2, T4, T5, and T6, each step is an object with an integer index and a string title. For T3, steps is an array of strings; positions are determined by array order.

Procedure IDs are zero-based. Step indices and answer positions are one-based. An id in the main corpus and the same id in StepBench-Val identify different procedures; preserve the split or corpus label when combining records. Do not join files by row position because some task files omit procedures.

T1 and T2: multiple-choice selection

Field	JSON type	Description
`options`	Array of strings	Four candidate steps in presentation order.
`answer.correct_index`	Integer	One-based position of the correct option in `options`.
`answer.correct_title`	String	Correct step text.
`answer.correct_index_in_task`	Integer	T2 only: the one-based index of the step to hide in the stored reference sequence.

T3: incorrect-step detection

Field	JSON type	Description
`answer.correct_index`	Integer	One-based position of the substituted step in the displayed sequence.
`answer.incorrect_step_text`	String	Inserted step text.
`answer.original_step_text`	String	Reference text replaced during task construction.

T4: step reordering

gold_answer is an array of one-based indices referring to the displayed, shuffled steps. Reading those steps in the order specified by gold_answer reconstructs the reference procedure. For example, [3, 1, 2] means the third displayed step comes first, followed by the first and second displayed steps.

T5: next-step generation

Field	JSON type	Description
`input_context`	Array of step objects	Ordered prefix shown to the model.
`target`	String	Reference next-step text.
`target_index`	Integer	One-based position of the target in the full reference procedure.

T6: full-plan generation and provenance

T6 uses the curated procedure pool directly. Its steps field contains the complete reference plan. Additional fields are:

Field	JSON type	Description
`url`	String	Source wikiHow article URL.
`method_id`	Integer	Source method identifier within the article.
`category_leaf`	String	StepBench-Val only: original leaf category before mapping to the main taxonomy.

Model inputs and reference answers

Records include both task inputs and reference information. Construct model prompts from the appropriate fields:

Task	Model-visible input	Reference used for evaluation
T1	`method_title`, all `steps` except the final step, and `options`.	`answer.correct_index`
T2	`method_title`, `steps` with the step at `answer.correct_index_in_task` omitted, and `options`.	`answer.correct_index`
T3	`method_title` and the modified `steps`.	`answer.correct_index`
T4	`method_title` and the shuffled `steps`.	`gold_answer`
T5	`method_title` and `input_context` only.	`target`
T6	`method_title` only.	Reference `steps`

Do not pass whole records directly to the model: stored answers and reference steps can reveal the solution. In particular, the full steps array in T1, T2, and T5 still contains the withheld target.

StepBench-Val: the 2026 corpus

The 2026 collection contains 121 source articles and 544 candidate methods. Filtering retains 214 procedures; curation removes eight steps, leaving 1,034 reference steps. The retained procedures come from 94 of the collected articles. Categories are mapped to the main taxonomy, with original leaf categories preserved in T6 records.

Evaluation and limitations

T1-T3 use exact-match accuracy on the selected position. T4 supports exact-match ordering accuracy and normalized edit distance. T5 and T6 use reference-based text metrics such as ROUGE and BERTScore; StepEval provides a complementary judge-based assessment of procedural failures.

StepBench-Val was collected to examine performance on more recent source articles. Its later article creation dates do not by themselves establish the absence of training-data contamination for every evaluated model. The two corpora also differ in size, category distribution, procedure lengths, and parts of the construction pipeline.