Datasets:

olliepro
/

BASIC

pretty_name: BASIC 10K
license: odc-by
language:
  - en
  - multilingual
task_categories:
  - text-generation
size_categories:
  - 10K<n<100K
tags:
  - chain-of-thought
  - reasoning
  - supervised-fine-tuning
  - interpretability
  - controllability
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*

BASIC 10K

BASIC (Better Abstractions with Structure for Interpretability and Control) is a 10K-example supervised fine-tuning dataset for structured reasoning. Instead of one unbroken chain of thought, each trace alternates between a short decision and a longer execution:

<think>
<steer>Choose the next high-level step</steer>
<exec>Carry out that step in detail...</exec>
...
</think>
Final answer

This dataset accompanies our paper BASIC: Isolating Key Decisions During LLM CoT and its reference implementation. The format pulls high-impact decisions out of the surrounding reasoning, making them easier to inspect, change, and sample separately from the lower-level execution.

Dataset construction

We drew prompts from the Dolci-Think-SFT-7B dataset, stratifying across science, Python code, mathematics, multilingual chat, and instruction-following. A BASIC teacher then generated one or more complete structured responses for each selected prompt. These responses became the distillation examples in this release.

Earlier versions learned the markup without reliably following the hierarchy. To fix that, we trained the teacher so that each <exec> span follows the decision in the immediately preceding <steer> span, including when that decision is strongly off-policy.

The final release has 10,000 traces from 2,138 source prompts, so some prompts have multiple rollouts. We capped each trace at 16,384 tokens, then cleaned and filtered the generations before release.

Example from the dataset

Here is a real example from the dataset (source_index=17, rollout_index=0).

User:
Determine the order, degree, linearity, unknown function, and independent variable of
the differential equation \( y'' - 5x(y')^4 = e^x + 1 \).

Assistant completion:
<think>
<steer>Define the goal</steer>
<exec>Okay, so I need to figure out the order, degree, linearity, unknown function,
and independent variable for the differential equation \( y'' - 5x(y')^4 = e^x +
1 \). Hmm, let's start by recalling what each of these terms means.</exec>
<steer>Determine the order</steer>
<exec>First, the order of a differential equation is determined by the highest
derivative present in the equation. Looking at the equation, I see \( y'' \) which is
the second derivative of y with respect to x. There's also \( y' \), which is the
first derivative, but since the highest is second, the order must be 2. So, order =
2.</exec>
...

Dataset structure

The repository has one train split in Parquet format. Each record includes:

Field	Type	Description
`source_index`	integer	Index of the selected source prompt.
`custom_id`	string	Identifier inherited from the source example.
`ground_truth`	string	Source-provided reference answer when available; otherwise empty.
`prompt`	list of messages	System/user conversation before the generated assistant response.
`messages`	list of messages	Complete training conversation, including the structured assistant response.
`completion`	string	Generated assistant response containing alternating `<steer>` and `<exec>` spans.
`final_answer`	string	Answer text extracted from the generated completion.
`steer_count`	integer	Number of `<steer>` spans in the completion.
`exec_count`	integer	Number of `<exec>` spans in the completion.
`length_tokens_total`	integer	Token count recorded during dataset generation.
`rollout_index`	integer	Rollout number for the source prompt.

Every field is populated in every record. For chat-style supervised fine-tuning, use messages. For completion-style pipelines, use prompt and completion.

BASIC format

BASIC traces alternate between decision--execution pairs:

(<steer> decision </steer>, <exec> execution </exec>)

The decision is a short, imperative instruction; the execution carries it out in detail. In our decoding setup, <steer> spans are limited to 15 tokens and <exec> spans to 512 tokens. Structured decoding enforces this grammar and lets the two span types use different sampling parameters.

Add these four tokens to the tokenizer before training:

<steer>  </steer>  <exec>  </exec>

Training setup

In our experiments, we used a deterministic 95/5 training/evaluation split (9,500/500 records; shuffle seed 42), assistant-only supervision, packed 16,384-token sequences, and a checkpoint after two epochs. The optimizer settings were adamw_torch, learning rate 7e-6, betas (0.9, 0.95), epsilon 1e-6, weight decay 0.1, and bfloat16 precision.

Intended use

We built BASIC for research on:

supervised fine-tuning of structured reasoning models;
inspection and intervention at explicit reasoning boundaries;
faithfulness to on-policy and off-policy steering decisions;
decision-level exploration and adaptive inference; and
interpretability and control of long-form reasoning.

The dataset is not a source of verified answers or a deployment-ready safety mechanism. Both the reasoning traces and their final answers can be wrong.

Limitations and responsible use

We evaluate mathematical reasoning, two model sizes, and controlled diversity tasks. We have not established that the results carry over to other domains, larger models, longer trajectories, or tool use.

More control over chain-of-thought can help with auditing, but it can also enable harmful steering or make a model look more faithful than it really is. Before any real-world use, we recommend access controls, logging, isolation from untrusted inputs, and independent checks of model outcomes. The source data is broad and multilingual, so generations may inherit errors, biases, unsafe material, or personal information from the prompts and teacher model. Apply whatever additional filtering your use case requires.

License and attribution

BASIC is released under the Open Data Commons Attribution License 1.0 (ODC-By-1.0). It derives from the Allen Institute for AI's Dolci-Think-SFT-7B, which is also distributed under ODC-By-1.0 and intended for research and educational use under Ai2's Responsible Use Guidelines. Downstream users must preserve attribution and review the upstream terms.

Citation

Please cite the accompanying paper:

@inproceedings{proudfoot2026basic,
  title = {{BASIC}: Isolating Key Decisions During {LLM} {CoT}},
  author = {Proudfoot, Oliver and Perrault, Andrew},
  booktitle = {NeurIPS 2026 Workshop on Interpretability for Discovery},
  year = {2026},
  url = {https://github.com/olliepro/BASIC}
}

Integrity

The SHA-256 checksum of the released Parquet shard is recorded in CHECKSUMS.sha256.