---
license: apache-2.0
language:
- en
task_categories:
- text-generation
- question-answering
tags:
- reasoning
- chain-of-thought
- distillation
- synthetic
- small-language-models
size_categories:
- 10K<n<100K
configs:
- config_name: default
  data_files:
  - split: train
    path: data/openthink.jsonl
- config_name: hybrid
  data_files:
  - split: train
    path: data/openthink_hybrid.jsonl
---

# OpenThink

OpenThink is 43,101 **short** reasoning traces for fine-tuning small language models (around 100M parameters). Most reasoning datasets are written for large models and run to thousands of tokens; OpenThink's median trace is **116 tokens**, short enough for a sub-150M model to learn from and reproduce.

Every trace is **self-consistency checked**: the solver answered each question twice, independently, and only questions where both answers agree are kept.

## Example

```json
{"category": "deduction", "subtopic": "before/after ordering", "solver": "mimo-v2.6-flash",
 "question": "At a market, Diego buys bread at 8:15, sells a hat at 8:40, buys fruit after selling the hat, and sells a vase before buying the bread. Which transaction happened third?",
 "trace": "The timeline of transactions:\n\n1. Sells a vase (must be before 8:15)\n2. Buys bread at 8:15\n3. Sells a hat at 8:40\n4. Buys fruit (must be after 8:40)\n\nThe third transaction is selling a hat at 8:40.\n\nFinal answer: Selling a hat",
 "answer": "selling a hat", "agree": true, "both_finals": ["selling hat", "selling a hat"], "out_tok": 153}
```

Every trace ends with a `Final answer:` line.

## Contents

| Category | Rows |
|---|---:|
| quantitative | 9,623 |
| everyday-logic | 8,734 |
| code-trace | 7,742 |
| deduction | 6,404 |
| cause-effect | 5,656 |
| reading-inference | 4,942 |
| **total** | **43,101** |

| Field | Meaning |
|---|---|
| `category`, `subtopic` | cell of the generation grid the question came from |
| `question` | the question, written by the question model |
| `trace` | the solver's reasoning, ending in `Final answer: ...` |
| `answer` | the normalized final answer |
| `both_finals` | the final answers of the two independent solves |
| `agree` | always `true` (rows that disagreed were dropped) |
| `solver`, `out_tok` | solver model and the trace's output token count |

### Configs

- **`default`** (`data/openthink.jsonl`): every row with its full reasoning trace.
- **`hybrid`** (`data/openthink_hybrid.jsonl`): the same 43,101 questions, but 10,022 rows (almost all cause-effect and reading-inference) keep only the `Final answer:` line. This is the recipe used for [Boris-2-Think](https://huggingface.co/opencerebral/Boris-2-Think).

## How it was made

1. **Question.** GLM-5.3-flash writes one checkable question from a grid of six categories and many subtopics.
2. **Solve twice.** MiMo-v2.6-flash solves it two times independently, concisely (at most about 120 words), ending with a `Final answer:` line.
3. **Self-consistency filter.** Keep only questions where both final answers match after normalization (times, numbers, and prefix or substring equality, since an exact string match wrongly dropped about 23% of good pairs). About 74% of questions pass.
4. **Deduplicate.** Near-duplicate templates (same content words, digits removed) are collapsed.
5. **Decontaminate.** Every question was 13-gram checked against the evaluation splits of ARC-Easy, ARC-Challenge, HellaSwag, SciQ, OpenBookQA and WinoGrande. Nothing was flagged. PIQA failed to load in that pass, so it was checked separately afterwards: questions and traces against all 4,922 PIQA validation and test items, 0 shared 13-, 10- or 8-word sequences.

   Questions and traces were also checked against all 1,000 items of ArithMark-3 (context plus correct ending):

   | Check | Result |
   |---|---|
   | Exact match (normalized) | 0 |
   | Shared 13-, 10- or 8-word sequences | 0, 0, 0 |
   | Identical set of numbers **and** the same final answer | 238 pairs, all different problems (highest content-word overlap 0.10) |

   The numeric matches are coincidences of small numbers: for example, "5 equal pieces, ate 4, left 1" against "5 granola bars shared by 4 people, 1 left". Scripts and full reports are in [`decontamination/`](./decontamination). Not checked against GSM8K.

Agreement between two solves is a filter, not a proof: some rows will still have wrong answers, especially in the open-ended cause-effect and reading-inference categories.

## Results

Fine-tuning on OpenThink measurably helps small models. Fine-tuning the 144M-parameter [Boris-2](https://huggingface.co/opencerebral/Boris-2) on the hybrid config (2 epochs, about 5 minutes on one V100) gave [Boris-2-Think](https://huggingface.co/opencerebral/Boris-2-Think):

| Benchmark | Boris-2 | Boris-2-Think |
|---|---:|---:|
| ARC-Easy | 59.76 | 63.93 |
| ARC-Challenge | 32.00 | 34.81 |
| ArithMark-3 | 45.10 | 49.20 |
| SciQ | 85.10 | 87.10 |
| Open SLM Index | 34.15 | 36.05 |

An earlier ablation on Boris-2-Preview-2 (two seeds each) separated the effect of the traces from the effect of the questions and answers. Answer-only fine-tuning gave +2.1 Index and full traces +3.0. The traces specifically helped arithmetic (ArithMark-3 +4.3 over answer-only) and slightly hurt HellaSwag (−0.5), which is why the hybrid recipe drops the traces for commonsense-style categories.

## Credits

Built by [OpenCerebral](https://huggingface.co/opencerebral) and published by the [SLM Consortium](https://huggingface.co/slmconsortium). The generation API credits were donated by **DQN Labs**; thank you.

## Copyright & License

*Copyright 2026 OpenCerebral, the SLM Consortium and DQN Labs*

This dataset and all associated files (the "Work") are licensed under the Apache
License, Version 2.0 (the "License"); you may not use this dataset except in
compliance with the License. You may obtain a copy of the License at:

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.