Using an LLM to generate training data for another is among the most general ways to train one, and it remains common practice. Some frontier teams have closed that route for their own models: what comes back is an answer, or a short summary, without the detailed reasoning trace behind it. That is a little ironic: they were themselves built on distilling human knowledge, and distilling an open-source model is still entirely routine; the restriction applies to their own outputs alone. Recent work recovers the hidden reasoning by replaying encrypted blocks across models. It somehow works, but it breaks the providers' terms of service, so it is not something a product can be built on long-term. We built the alternative. We take the context and the teacher's answer as input, and generate the reasoning trace ourselves, in the style of the student's own model family. Training is two-stage, supervised and then adversarial: a generator learns to regenerate the family's own reasoning traces from their context and answer, and a critic learns how real a reasoning trace looks. Applied to a teacher's answer, the generator writes one in the family's style. An independent judge rates how likely traces are to be genuine on a scale from 0 to 1: ours average 0.68, real traces 0.66, and traces selected by the critic from four candidates 0.82. These are authenticity scores, not correctness rates. We test the idea on five benchmarks with everything else held fixed. On general tasks the five training corpora are about the same; on coding, the generated reasoning beats Fable 5's own thinking content. With the same 5,000 questions and the same teacher answers, HumanEval+ improves by 3.7 points and MBPP+ by 7.1 at the final checkpoint, and the MBPP+ lead holds at every checkpoint. We suspect that reasoning written in the student's family style is easier for it to learn from.
Figures & tables
Figure 1: Same answers, better traces. HumanEval+ (left) and MBPP+ (right) across training. Against the model trained on Fable 5’s own traces, ours with Fable 5’s answers wins at nearly every checkpoint. Both of our models, with Fable 5 and with GPT-6.1-SOL as the teacher, are far better than the one trained with Qwen3.8-Max as teacher.
Figure 2: The pipeline. A conversation is a system prompt, user turns, tool calls and responses, an answer, and the reasoning trace that sits before the answer. Training the generator (blue) takes the conversation with the reasoning trace removed and restores it as the target (green). The critic (purple) is shown a real reasoning trace and a generated one and must say which is which. The generator is then trained against the critic’s verdict (arc).
Corpus
ARC-E
ARC-C
BoolQ
HumanEval+
MBPP+
S1: Fable 5 reasoning + answer
81.02
58.36
89.63
64.63
52.38
S2: family-native + Fable 5 answer
81.19
59.73
89.33
68.29
59.52
S3: Qwen-Max reasoning + answer
81.52
58.28
88.35
46.95
24.60
S4: TraceInversion + Sol answer
81.48
58.53
88.99
3.66
6.61
S5: family-native + Sol answer
80.98
58.19
88.65
59.15
60.05
Table 1: Five corpora at the final checkpoint ( ≈ 1,600 packed-batch updates). Multiple-choice columns are acc-norm for ARC and accuracy for BoolQ; code columns are pass@1 on the plus suites. S4 is the strongest of the five at step 900 ( 21.95 and 42.59 ) and the weakest at the end, which is a collapse rather than a flat line. One run per cell.
Step
300
600
900
1,200
1,600
HumanEval+
S1 teacher reasoning
52.44
66.46
61.59
33.54
64.63
S2 family-native
58.54
56.10
66.46
67.07
68.29
S3 Qwen-Max reasoning
48.78
35.37
31.71
43.29
46.95
S4 TraceInversion
7.93
10.98
21.95
17.68
3.66
S5 family-native + Sol
0.61
13.41
42.07
48.17
59.15
Table 2: Coding accuracy at every checkpoint. pass@1 on HumanEval+ (upper block) and MBPP+ (lower block); Fig. 1 plots the same numbers.
A standard recipe for distilling the reasoning ability of large language models (LLMs) is to sample chains of thought from the model, keep those that reach the correct final answer, and fine-tune on the survivors. When sampling fails, a common fix shows the generator the gold answer and asks it to write a chain that reaches that answer. We show that this second step degrades the training data in a way that correctness filtering cannot catch. We run a controlled experiment that fixes the generator, the problem set, and the correctness filter, and varies only whether the chain is generated under answer-conditioning, the gold answer shown with a request to reach it. Training a strong instruction-tuned reasoning model on its own answer-conditioned chains sharply lowers its verifiable-reasoning accuracy. The loss grows with difficulty, reaching as much as about 27 points on the hardest competition problems. The mechanism is legible in the chains themselves, which rationalize backward from the shown answer instead of deriving it, with the early final-answer statement as the measurable symptom. The harm is a property of the data rather than the generator, read off unlabeled generations before any fine-tuning, ordering the penalty across eight thinking models from four families, and transferring across teacher families. A prompt ablation localizes it to the rationalize-toward instruction rather than the answer's bare visibility. The practical takeaway is to generate answer-blind, because no correctness filter can see this damage in the data.
Jungseob Lee, Seungyoon Lee, Suhyune Son +4
1Korea University · 2Zoom Communications · 3Yonsei University
Recent advances in large language models (LLMs) have shown that test-time scaling can substantially improve model performance on complex tasks, particularly in the coding domain. Under this paradigm, models use a larger token budget during inference to generate intermediate reasoning traces before producing a final answer. However, current evaluations primarily rely on competitive programming benchmarks, which may not capture the full range of reasoning abilities. In this work, we perform a systematic study of frontier reasoning models to understand their performance on real-world coding benchmarks. To gain more insights into the performance of such models, we devise a programmatic way to {\em automatically generate} coding tasks of arbitrary difficulty and structure from existing benchmarks. Using this framework, our analysis reveals that the structure of a reasoning trace, not just its contents, is a strong predictor of correctness. Motivated by this, we propose structured thought-trees as means to represent reasoning traces. To illustrate their use, we train a lightweight classifier on features extracted from thought-trees to predict trace correctness, and demonstrate that flagging and retrying structurally anomalous traces based on the extracted features yields consistent gains at lower complexity levels.
Chain-of-thought traces from large reasoning models can span tens of thousands of tokens, yet we lack a vocabulary for describing their internal structure. Previous methods developed to analyze chain-of-thought traces are either too rigid or not expressive enough, failing to capture features across domains and models. To remedy this, we develop ReasonOps, an unsupervised, expressive method for annotating chain-of-thought traces, providing succinct universal operators. Using ReasonOps, we analyze 44,662 traces from 12 thinking LLMs spanning 6 families across 8 reasoning benchmarks and discover that they share a common compositional structure: 7 recurring reasoning operators -- discourse-level moves such as backtracking, inferring, and hypothesizing -- that emerge from unsupervised clustering of sentence-initial 3-token pivots. These operators appear across every model family and benchmark domain, confirmed by three independent LLM judges who classify held-out samples at 70 -76% accuracy. We analyze the structure of operators on easy vs. hard problems, revealing that reflective operators are more helpful on hard problems and harm performance on easy problems. Operator sequences are highly model-identifying: a classifier trained on operator distributions alone recovers the source model with macro-AUC, revealing that each model family has a distinctive reasoning fingerprint. Structural operator features predict within-problem answer correctness well above baselines. Classifiers built on these operators reach WP-AUC and on AIME specifically. ReasonOps further enables early quality estimation well before the trace completes: we predict at WP-AUC for only 50% of the trace. The ReasonOps pipeline is unsupervised and annotation-free, enabling deep insights into LLM reasoning traces as well as strong downstream results on model identification and correctness prediction.