---
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.png)

# 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

```text
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:

```bash
pip install datasets
```

Load one task and split:

```python
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:

```python
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.