Pith. sign in

REVIEW 4 major objections 5 minor 7 cited by

OpenRFT: Adapting Reasoning Foundation Model for Domain-specific Tasks with Reinforcement Fine-Tuning

T0 review · 4 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read With only 100 domain samples per task, a three-part recipe of self-distilled reasoning, process-reward RL, and data augmentation lifts a generalist reasoning model's accuracy by an average of 11%.

desk verdict An honest early RFT recipe with useful components and an interesting teacher-student finding, but the headline 11% gain lacks error bars and the full pipeline underperforms its own ablation. read the letter →

arxiv 2412.16849 v1 pith:MWGKR26B submitted 2024-12-22 cs.AI

Yuxiang Zhang , Yuqi Yang , Jiangming Shu , Yuhang Wang , Jinlin Xiao , Jitao Sang This is my paper · ORCID
classification cs.AI
keywords reinforcementfine-tuningreasoningfoundationmodelsprocessrewardmodeldataaugmentationself-distillationfew-shotin-contextlearningSciKnowEvalPPO
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

OpenRFT asks whether the recently announced reinforcement fine-tuning paradigm can be reproduced openly with a generalist reasoning model and very few domain examples. The paper's answer is yes: with 100 training samples per task, it builds a pipeline that rewrites questions, self-distills reasoning traces, and then runs PPO with a process reward model that scores each step. On eight scientific multiple-choice tasks from SciKnowEval, the best pipeline, supervised fine-tuning followed by process-reward RL with data augmentation, raises average accuracy from 0.403 to 0.447, an 11 percent relative gain over the unmodified base model. A reader should care because this is a concrete recipe for turning a strong general reasoner into a specialist on tiny datasets, and because the experiments isolate which ingredients matter.

What carries the argument

The load-bearing object is a language-augmented Markov decision process in which a reasoning step or answer prediction is an action, and the reward for each step is produced by a process reward model. The central identity is the blended reward $R_i = \alpha \times or_i + (1-\alpha) \times f(pr_i^1,\ldots,pr_i^m)$, where $or_i$ is 1 if the final answer matches and 0 otherwise, $f$ aggregates step scores (e.g., mean or minimum), and $\alpha=0.7$. This reward is optimized with PPO after an SFT warm start built from self-synthesized reasoning traces; data augmentation expands the 100 samples sixfold, and a sentence-embedding retriever selects the top-three similar examples as in-context context. The action-space alignment of teacher, policy, and PRM is the mechanism invoked to explain why self-distillation succeeds while distillation from a stronger model fails.

What would settle it

Take the best pipeline and replace each PRM step score with a random permutation of the same scores while keeping the final-answer reward identical; if accuracy stays at 0.447 within noise, then process supervision is not the active ingredient. A complementary check is to run the full pipeline on an unseen ninth SciKnowEval task and see whether the 11% gain reproduces.

Watch

Extended reading notes

Core claim

In the paper's own terms, the discovery is that reinforcement fine-tuning of a reasoning foundation model is feasible with only 100 domain-specific (question, answer) pairs, provided the limited samples are exploited in three coordinated ways: rewriting questions and shuffling options to augment the RL training set, using the policy model itself to synthesize reasoning steps and warm-starting with SFT, and injecting domain knowledge through few-shot in-context learning. The reward is a weighted blend of outcome correctness and PRM step scores, $R_i = \alpha \cdot or_i + (1-\alpha) \cdot f(pr_i^1,\ldots,pr_i^m)$ with $\alpha=0.7$. The strongest result is that SFT+RL(PRM)+DA achieves 0.447 average accuracy versus 0.403 for vanilla, the best among all open Skywork-initialized methods. The paper also reports that distilling reasoning traces from a stronger but action-space-misaligned teacher (QwQ-32B) drops accuracy to 0.31, below the 0.40 vanilla baseline, which the authors read as evidence that teacher-student action-space alignment matters more than raw teacher strength.

Load-bearing premise

The whole recipe depends on the process reward model giving trustworthy step-level scores in the same action space as the policy model; if the PRM mis-scores reasoning steps, RL can be pushed toward flawed chains even when final answers are right, and the authors note this alignment is not guaranteed.

Editorial extensions

If this is right

  • With only 100 samples per task, the best OpenRFT pipeline (SFT + RL with process reward + data augmentation) improves average accuracy by 11% over the vanilla reasoning model, and beats both outcome-only RL (ReFT) and SFT alone.
  • Data augmentation contributes most when the training set is small; its benefit shrinks as more real samples are added, suggesting that augmented questions carry some noise.
  • Using a stronger but misaligned teacher model for reasoning distillation can be worse than no distillation, because inconsistent step-level action spaces corrupt the SFT warm start.
  • Adding few-shot ICL to the RL prompt does not help overall accuracy, but it helps the hardest task (molecule structure prediction), leaving domain-knowledge injection as an open direction.
  • More domain-specific training data improves all RL-based variants, so RFT remains data-hungry even though it needs far fewer samples than conventional SFT.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If action-space alignment is the dominant mechanism, a direct extension is to normalize reasoning-step formats across teacher and student (or fine-tune the PRM on the student's step distribution); the paper's own QwQ result predicts this would turn SFT+ from a 0.31 failure into a gain.
  • The reported gains could be tested for dependence on process supervision by shuffling the PRM's step scores within each rollout while keeping the final-answer reward; if accuracy stays near 0.447, outcome reward alone is doing the work.
  • The results are all on multiple-choice tasks with extractable final answers; transferring the recipe to free-form scientific outputs would require new reward definitions, so the 11% claim should not be assumed to generalize.
  • Self-distillation plus augmentation creates a self-generated data loop, suggesting a self-play variant where the policy's correct rollouts are added back to the training pool could compound the gains beyond a static 100-sample budget.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes OpenRFT, an open-source implementation of reinforcement fine-tuning (RFT) for adapting a generalist reasoning model to domain-specific multiple-choice tasks using only 100 training samples per task. The method combines three uses of the limited domain samples: question rewriting and option shuffling for data augmentation (DA); supervised fine-tuning (SFT) on reasoning traces synthesized by the policy itself (or by a stronger teacher); and PPO reinforcement learning with a process reward model (PRM), optionally augmented with few-shot in-context learning (ICL). The evaluation is on eight SciKnowEval L3 tasks spanning biology, chemistry, physics, and materials science. The main reported result is that SFT+RL(PRM)+DA achieves an average accuracy of 0.447 versus 0.403 for the unmodified Skywork-o1-Open-Llama-3.1-8B policy, an average improvement of about 11%, while the full pipeline with ICL scores 0.443. The paper also reports that using a stronger teacher model (QwQ-32B-Preview) for distillation hurts performance, which it attributes to teacher-student action-space mismatch, and it explicitly labels the work as an early exploration that will be updated.

Significance. If the central empirical claim were statistically robust, the paper would make a useful contribution: it provides a concrete, open-source recipe for RFT-style fine-tuning with very few domain samples, decomposes the pipeline into modules that can be ablated, and is candid about failure modes such as the ICL degradation and the teacher-alignment problem. The release of source code, datasets, and models is a genuine strength, as is the attempt to study the action-space alignment issue empirically rather than assuming it away. However, the headline result is not yet established: no uncertainty quantification is reported, the full proposed pipeline underperforms its own ablated variant, and the teacher-distillation experiment shows a large negative effect that the paper explains only by an untested assumption. The paper is therefore best viewed as a promising preliminary technical report whose main quantitative claim needs additional evidence.

major comments (4)
  1. [Section 3.4, Table 1] The headline claim that SFT+RL(PRM)+DA achieves an average improvement of 11% over Vanilla is not statistically supported. The text says three evaluations were performed and averaged, but no standard deviations, confidence intervals, or significance tests are reported. With 100 test questions per task (49 for T7), the standard error of a single task accuracy is up to about 0.05, and several contributing per-task deltas are of that magnitude (e.g., T1: 0.28 to 0.29; T5: 0.45 to 0.47). The across-task average gap of 0.044 could therefore be within sampling noise, especially since no information is given about the variability of the train/test split or the RL seed. Moreover, the full OpenRFT configuration SFT+RL(PRM)+DA+ICL (0.443) is numerically worse than the ablated SFT+RL(PRM)+DA (0.447), so the improvement is not robustly tied to the complete proposed method. Please report per-run results, standard deviations or confidence intervals, and paired tests across tasks, and re-state the central claim to clearly distinguish the best ablated variant from the full pipeline.
  2. [Section 3.5, Table 2] The teacher-alignment experiment raises a load-bearing issue for the SFT-based imitation module of Section 2.2. SFT+ (distilling reasoning data from the stronger QwQ-32B-Preview model) performs substantially worse than SFT with self-distilled data and even worse than Vanilla (0.31 vs 0.40 average). The paper attributes this to teacher-student action-space mismatch, but no controlled experiment isolates that cause from other differences, such as reasoning-data quality, prompt format, or the fallback strategy of replacing failed rollouts with the true answer after 64 sampling attempts. Since the deployed OpenRFT pipeline relies on self-distillation rather than a stronger teacher, the paper should provide evidence that self-synthesized traces are reliable, and it should test the action-space hypothesis directly by, for example, reformatting teacher traces into the student's action space before SFT.
  3. [Section 2.3.2 and footnote 3] The reward design rests on an unverified assumption about the process reward model. The combined reward R_i = alpha * ori + (1-alpha) * f(pr_i) depends on the PRM's step-level scores, but footnote 3 states that the provider has not confirmed whether the action spaces of the policy model and the PRM are aligned. If the PRM systematically mis-scores reasoning steps, the PPO update can be pushed toward flawed chains even when final answers are correct. The paper does not report any sensitivity analysis for alpha, any evaluation of PRM accuracy on the eight tasks, or any comparison of alternative aggregation functions f(.). Please provide at least a quantitative sanity check (for example, correlation between PRM process scores and outcome correctness, or an ablation with alpha=1) to support the reward design.
  4. [Section 3.1 and Section 3.3] The experimental setup does not fully specify the data split and the leakage risk of data augmentation. The paper says 100 training and 100 test samples are sampled from each dataset, but it does not state how the split was performed, whether the augmented questions were generated only from the training set, or whether any check was made for overlap or near-duplicates between augmented training questions and test questions. Since the augmentation rewrites question stems and shuffles options, a leakage check is needed to ensure the reported gains are not inflated by memorizing test-like rephrasings. Please clarify the split procedure and add a similarity or containment check.
minor comments (5)
  1. [Throughout] There are typos and minor wording issues, including 'vanila' (Section 2.2.1), 'rewerd' (Section 3.2), and 'recomputing function' (Section 2.3.2); these should be corrected in a revision.
  2. [Section 2.2.1] The notation is inconsistent: the sampled reasoning data are written as (Qi, ..., S^i_j, ..., A'_i) and the final synthesized data as (Qi, Si, Ai), but the relationship between A'_i and Ai is not made explicit, and the 'at least one data that can infer the correct answer' selection criterion is informal.
  3. [Section 3.5, Figure 3] The caption mentions a 'light green dashed line' representing SFT with 100 samples, but the figure is not visible in the manuscript text and the marker is not described in the body; please ensure the figure is legible and the legend is explained.
  4. [References] The reference list contains a malformed entry for 'ope, 2024' (Open O1), and the Sentence-BERT model used for ICL retrieval is not cited; please fix the citation format and add the missing reference.
  5. [Section 3.3] The description of the fallback for failed distillation rollouts says the true answer is 'directly used as the response in the training data' when 64 attempts fail; it would be clearer to state whether this creates a reasoning-less (Q,A) example and how such examples affect the SFT loss.

Circularity Check

0 steps flagged · score 0.0 of 10

OpenRFT is an empirical systems report; its headline accuracy gain is benchmarked against external SciKnowEval labels, and no prediction is derived from its own inputs by construction.

full rationale

The paper's central claim is an empirical comparison: SFT+RL(PRM)+DA reaches 0.447 average accuracy versus 0.403 for Vanilla (Table 1, Section 3.4). This is evaluated on SciKnowEval test questions sampled independently of the 100 training samples per task, using the ground-truth answer as the outcome reward (Section 2.3.2), so the reported accuracy is not defined in terms of the model's own training signal. The self-distillation component, where the policy synthesizes its own reasoning data for SFT, is disclosed in footnote 1 ('the synthesis is instead performed by the policy model itself') and is a self-referential training loop that could reinforce biases, but the final claim is tested against external correctness labels rather than the model's own rollouts, so it does not make the result true by construction. The only directly relevant self-citations (o1-Coder, Wang & Sang) are contextual related-work references and carry no load-bearing weight. The unverified PRM action-space alignment is explicitly flagged in footnote 3 as a possible performance limitation, not hidden as a derivation. Statistical concerns raised by the reader -- no error bars or significance tests, small 100-question test sets, and the full ICL configuration scoring below its DA ablation -- are correctness and robustness risks, not circular reductions, and do not affect the circularity score.

Assumptions & free parameters 6 free parameters · 4 assumptions · 0 invented entities

The pipeline relies on several hand-chosen hyperparameters and on the validity of the external PRM and augmentation model; no new physical entities are introduced.

free parameters (6)
  • alpha (reward combination weight) = 0.7
    Controls balance between outcome reward and process reward in total reward; chosen by hand, not fitted, but affects policy updates.
  • data augmentation factor = 6x (600 samples from 100)
    Number of augmented variants per question; affects amount of synthetic training data.
  • ICL top-k = 3
    Number of retrieved similar examples used in few-shot context during RL; affects domain knowledge injection.
  • LoRA rank = 4
    Rank of LoRA adapter for both SFT and RL; capacity constraint.
  • KL coefficient = 0.01
    PPO KL penalty coefficient to prevent policy drift.
  • max sampling attempts for correct rollouts = 64
    Number of rollout attempts before falling back to using the true answer without reasoning steps.
assumptions (4)
  • standard math PPO is a valid RL optimization algorithm
    The paper uses PPO as the RL trainer and cites Schulman et al. (2017).
  • domain assumption The process reward model provides valid step-level rewards
    In Section 3.3 the paper relies on Skywork-o1-Open-PRM to score reasoning steps; if this model is miscalibrated, the combined reward is misleading.
  • domain assumption GPT-4o-mini question rewriting preserves the original answer and semantics
    Section 2.1 augments data by rephrasing questions; errors in rewrites could change the correct answer.
  • domain assumption The policy model and PRM action spaces are compatible enough
    Footnote 3 in Section 3.3 notes the provider has not confirmed aligned action spaces, which may impact RFT performance.

how reviews work

0 comments
Cite this review

Pith. "Pith review of OpenRFT: Adapting Reasoning Foundation Model for Domain-specific Tasks with Reinforcement Fine-Tuning." pith.science (2026). https://pith.science/paper/MWGKR26B

@misc{pith2026241216849,
  author       = {Pith},
  title        = {Pith review of: OpenRFT: Adapting Reasoning Foundation Model for Domain-specific Tasks with Reinforcement Fine-Tuning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MWGKR26B}},
  note         = {Machine review of arXiv:2412.16849}
}
abstract

OpenAI's recent introduction of Reinforcement Fine-Tuning (RFT) showcases the potential of reasoning foundation model and offers a new paradigm for fine-tuning beyond simple pattern imitation. This technical report presents \emph{OpenRFT}, our attempt to fine-tune generalist reasoning models for domain-specific tasks under the same settings as RFT. OpenRFT addresses two key challenges of lacking reasoning step data and the limited quantity of training samples, by leveraging the domain-specific samples in three ways: question augmentation, synthesizing reasoning-process data, and few-shot ICL. The evaluation is conducted on SciKnowEval, where OpenRFT achieves notable performance gains with only $100$ domain-specific samples for each task. More experimental results will be updated continuously in later versions. Source codes, datasets, and models are disclosed at: https://github.com/ADaM-BJTU/OpenRFT

Figures

Figures reproduced from arXiv: 2412.16849 by the authors.

Figure 1
Figure 1. OpenRFT framework. 2.1 DATA AUGMENTATION Data augmentation (DA) is a widely used technique for addressing data scarcity. In this framework, we propose a data augmentation method based on question rewriting. Specifically, we first utilize GPT-4o-mini to rewrite the question stem while preserving its original meaning, generating multiple variations. Subsequently, the options for each question are shuffled independentl… view at source ↗
Figure 2
Figure 2. Task instructions for generating distinct expressions [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Performance with different sizes of domain-specific data. The light green dashed line [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Reasoning Flaw in Domain-Specific Data: This example shows a chemical equilibrium [PITH_FULL_IMAGE:figures/full_fig_p014_4.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 7 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. One Token to Fool LLM-as-a-Judge

    cs.LG 2025-07 conditional novelty 6.0 of 10

    LLM reward models falsely accept empty 'master key' responses such as ':' or 'Thought process:' across many models, and a fine-tuning defense reduces these false positives to near zero.

  2. Pass@k Training for Adaptively Balancing Exploration and Exploitation of Large Reasoning Models

    cs.LG 2025-08 conditional novelty 5.0 of 10

    Using Pass@k as an RLVR reward, with bootstrap sampling and an analytical advantage formula, improves exploration and later Pass@1 performance of reasoning LLMs.

  3. Reinforcement Learning Optimization for Large-Scale Learning: An Efficient and User-Friendly Scaling Library

    cs.LG 2025-06 conditional novelty 5.0 of 10

    ROLL is a distributed RL training library for LLMs with sample-level rollout scheduling and flexible device mapping, demonstrated on RLVR and agentic tasks but without baseline or scaling measurements.

  4. ReARTeR: Retrieval-Augmented Reasoning with Trustworthy Process Rewarding

    cs.CL 2025-01 conditional novelty 5.0 of 10

    ReARTeR improves RAG multi-step reasoning by combining a process reward model, an aligned explanation model, temporal-difference lookahead, and MCTS-based iterative preference training.

  5. Don't Command, Cultivate: An Exploratory Study of System-2 Alignment

    cs.CL 2024-11 conditional novelty 5.0 of 10

    Encouraging LLMs to analyze user requests step-by-step (System-2 Alignment) modestly improves safety on open-source models, but with trade-offs and limited evidence.

  6. A Survey of Slow Thinking-based Reasoning LLMs using Reinforced Learning and Inference-time Scaling Law

    cs.AI 2025-05 conditional novelty 3.0 of 10

    A structured survey of reasoning LLMs that use reinforcement learning and inference-time scaling to achieve slow, deliberate thought, organized into three method categories.

  7. Dynamic Chain-of-Thought: Towards Adaptive Deep Reasoning

    cs.AI 2025-02 reject novelty 3.0 of 10

    D-CoT claims to cut reasoning time, steps, and tokens versus DeepSeek R1, but the comparison is between a Python simulation and a real LLM, without any accuracy check.

Reference graph

Works this paper leans on

25 extracted references · 11 canonical work pages · cited by 7 Pith papers

  1. [1]

    https://github.com/Open-Source-O1/Open-O1/, 2024

    Open o1: A model matching proprietary power with open-source innovation. https://github.com/Open-Source-O1/Open-O1/, 2024

    work page 2024

  2. [2]

    Decore: Deep compression with reinforcement learning

    Manoj Alwani, Yang Wang, and Vashisht Madhavan. Decore: Deep compression with reinforcement learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp.\ 12349--12359, June 2022

    work page 2022

  3. [3]

    N2N Learning: Network to Network Compression via Policy Gradient Reinforcement Learning

    Anubhav Ashok, Nicholas Rhinehart, Fares Beainy, and Kris M Kitani. N2n learning: Network to network compression via policy gradient reinforcement learning. arXiv preprint arXiv:1709.06030, 2017

    work page Pith review arXiv 2017

  4. [4]

    Grounding large language models in interactive environments with online reinforcement learning

    Thomas Carta, Cl \'e ment Romac, Thomas Wolf, Sylvain Lamprier, Olivier Sigaud, and Pierre-Yves Oudeyer. Grounding large language models in interactive environments with online reinforcement learning. In International Conference on Machine Learning, pp.\ 3676--3713. PMLR, 2023

    2023

  5. [5]

    Reinforcement learning for fine-tuning text-to-image diffusion models

    Ying Fan, Olivia Watkins, Yuqing Du, Hao Liu, Moonkyung Ryu, Craig Boutilier, Pieter Abbeel, Mohammad Ghavamzadeh, Kangwook Lee, and Kimin Lee. Reinforcement learning for fine-tuning text-to-image diffusion models. Advances in Neural Information Processing Systems, 36, 2024

    work page 2024

  6. [6]

    Sciknoweval: Evaluating multi-level scientific knowledge of large language models, 2024

    Kehua Feng, Keyan Ding, Weijie Wang, Xiang Zhuang, Zeyuan Wang, Ming Qin, Yu Zhao, Jianhua Yao, Qiang Zhang, and Huajun Chen. Sciknoweval: Evaluating multi-level scientific knowledge of large language models, 2024

    work page 2024

  7. [7]

    Openrlhf: An easy-to-use, scalable and high-performance rlhf framework

    Jian Hu, Xibin Wu, Zilin Zhu, Xianyu, Weixun Wang, Dehao Zhang, and Yu Cao. Openrlhf: An easy-to-use, scalable and high-performance rlhf framework. arXiv preprint arXiv:2405.11143, 2024

    arXiv 2024

  8. [8]

    Alr2: A retrieve-then-reason framework for long-context question answering

    Huayang Li, Pat Verga, Priyanka Sen, Bowen Yang, Vijay Viswanathan, Patrick Lewis, Taro Watanabe, and Yixuan Su. Alr2: A retrieve-then-reason framework for long-context question answering. arXiv preprint arXiv:2410.03227, 2024

    arXiv

Show all 25 references
  1. [9]

    Reft: Reasoning with reinforced fine-tuning

    Trung Quoc Luong, Xinbo Zhang, Zhanming Jie, Peng Sun, Xiaoran Jin, and Hang Li. Reft: Reasoning with reinforced fine-tuning. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics, 2024. URL https://arxiv.org/abs/2404.03592

    2024 arXiv

  2. [10]

    Skywork-o1 open series

    Skywork o1 Team. Skywork-o1 open series. https://huggingface.co/Skywork, November 2024. URL https://huggingface.co/Skywork

    2024

  3. [11]

    Openai's reinforcement fine-tuning research program

    OpenAI . Openai's reinforcement fine-tuning research program. https://openai.com/form/rft-research-program/, 2024

    2024

  4. [12]

    Training language models to follow instructions with human feedback

    Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 35: 0 2...

    2022

  5. [13]

    Proximal policy optimization algorithms

    John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017

    2017 arXiv

  6. [14]

    Llama-o1: Open large reasoning model frameworks for training, inference and evaluation with pytorch and huggingface

    SimpleBerry. Llama-o1: Open large reasoning model frameworks for training, inference and evaluation with pytorch and huggingface. https://github.com/SimpleBerry/LLaMA-O1, 2024. Accessed: 2024-11-25

    2024

  7. [15]

    Openr: An open source framework for advanced reasoning with large language models

    OpenR Team. Openr: An open source framework for advanced reasoning with large language models. https://github.com/openreasoner/openr, 2024 a

    2024

  8. [16]

    Qwq: Reflect deeply on the boundaries of the unknown, November 2024 b

    Qwen Team. Qwq: Reflect deeply on the boundaries of the unknown, November 2024 b . URL https://qwenlm.github.io/blog/qwq-32b-preview/

    2024

  9. [17]

    Openr: An open source framework for advanced reasoning with large language models

    Jun Wang, Meng Fang, Ziyu Wan, Muning Wen, Jiachen Zhu, Anjie Liu, Ziqin Gong, Yan Song, Lei Chen, Lionel M Ni, et al. Openr: An open source framework for advanced reasoning with large language models. arXiv preprint arXiv:2410.09671, 2024

    arXiv

  10. [18]

    Don't command, cultivate: An exploratory study of system-2 alignment, 2024

    Yuhang Wang and Jitao Sang. Don't command, cultivate: An exploratory study of system-2 alignment, 2024

    2024

  11. [19]

    Qwen2 technical report

    An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Ma, Jin Xu, Jingren Zhou, Jinze Bai, Jinzheng...

    2024 arXiv

  12. [20]

    O1-coder: An o1 replication for coding, 2024

    Yuxiang Zhang, Shangxi Wu, Yuqi Yang, Jiangming Shu, Jinlin Xiao, Chao Kong, and Jitao Sang. O1-coder: An o1 replication for coding, 2024. URL https://arxiv.org/abs/2412.00154

    2024 arXiv

  13. [21]

    Marco-o1: Towards open reasoning models for open-ended solutions, 2024

    Yu Zhao, Huifeng Yin, Bo Zeng, Hao Wang, Tianqi Shi, Chenyang Lyu, Longyue Wang, Weihua Luo, and Kaifu Zhang. Marco-o1: Towards open reasoning models for open-ended solutions, 2024

    2024

  14. [22]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

  15. [23]

    @esa (Ref

    \@ifxundefined[1] #1\@undefined \@firstoftwo \@secondoftwo \@ifnum[1] #1 \@firstoftwo \@secondoftwo \@ifx[1] #1 \@firstoftwo \@secondoftwo [2] @ #1 \@temptokena #2 #1 @ \@temptokena \@ifclassloaded agu2001 natbib The agu2001 class already includes natbib coding, so you should ...

  16. [24]

    \@lbibitem[] @bibitem@first@sw\@secondoftwo \@lbibitem[#1]#2 \@extra@b@citeb \@ifundefined br@#2\@extra@b@citeb \@namedef br@#2 \@nameuse br@#2\@extra@b@citeb \@ifundefined b@#2\@extra@b@citeb @num @parse #2 @tmp #1 NAT@b@open@#2 NAT@b@shut@#2 \@ifnum @merge>\@ne @bibitem@firs...

  17. [25]

    @open @close @open @close and [1] URL: #1 \@ifundefined chapter * \@mkboth \@ifxundefined @sectionbib * \@mkboth * \@mkboth\@gobbletwo \@ifclassloaded amsart * \@ifclassloaded amsbook * \@ifxundefined @heading @heading NAT@ctr thebibliography [1] @ \@biblabel @NAT@ctr \@bibset...

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.