Pith. sign in

REVIEW 4 major objections 5 minor 2 cited by

CoIn: Counting the Invisible Reasoning Tokens in Commercial Opaque LLM APIs

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

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

Pith's one-line read For proprietary LLM APIs that hide their reasoning traces, CoIn claims a third-party auditor can verify both the number of hidden tokens and whether they are semantically relevant, catching token count inflation with up to 94.7% success.

desk verdict The paper's central claim—that CoIn verifies the number of hidden reasoning tokens—does not survive the threat model: the Merkle tree is built by the audited provider, so the commitment is non-binding and the proof only checks membership in the provider's chosen set. read the letter →

arxiv 2505.13778 v1 pith:UP3CPV47 submitted 2025-05-19 cs.AI

Guoheng Sun , Ziyao Wang , Bowei Tian , Meng Liu , Zheyu Shen , Shwai He , Yexiao He , Wanghao Ye
show 2 more authors
Yiting Wang Ang Li
This is my paper · ORCID
classification cs.AI
keywords tokencountinflationopaqueLLMAPIsreasoningtokensMerkletreeembeddingfingerprintssemanticrelevanceverificationbillingtransparencythird-partyauditing
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

CoIn tackles a billing transparency gap in commercial LLM APIs that hide their reasoning traces: users are charged for invisible reasoning tokens, often the majority of the cost, with no way to check whether the count is genuine. The paper claims that a trusted third-party auditor can verify both the quantity and the semantic validity of these hidden tokens without seeing the tokens themselves. Quantity is verified by hashing token embedding fingerprints into a Merkle tree and spot-checking Merkle proofs; semantic validity is verified by matching heads that score whether a token is coherent with its block and whether a block supports the final answer. The reported detection success reaches 94.7% under adaptive inflation attacks, with less than 40% embedding exposure and less than 4% token visibility. If the claim holds, opaque reasoning APIs can be made auditable for billing while keeping their proprietary chains of thought concealed.

What carries the argument

The load-bearing object is the token fingerprint: for a token $r_i$ inside block $B_j$, CoIn forms $\mathrm{Emb}_d(B_j) \parallel \mathrm{Emb}_d(r_i)$, hashes it as a Merkle leaf, and lets the Merkle root act as a commitment to the full hidden reasoning trace. Around this sits the matching head, a two-layer classifier that takes the feature vector $[a; b; a-b; a\odot b; \cos\_\mathrm{sim}]$ of two embeddings and outputs a relevance score in $[0,1]$. One matching head checks whether a token is coherent with its block, and another checks whether a block is relevant to the final answer; the Merkle proof supplies count integrity, and the two matching heads supply semantic relevance. A final verifier, either threshold averaging or a DeepSets classifier, aggregates the scores across sampled blocks into an accept or reject decision.

What would settle it

Have a provider commit a cryptographic summary over a genuine reasoning trace, then bill for an inflated count by repeating the last token's summary to pad the tree to a power of two, and run CoIn's count check; if the padded summary still verifies, the quantity check cannot distinguish an honest count from an inflated one.

Watch

Extended reading notes

Core claim

On its own terms, CoIn's central claim is that hidden reasoning tokens in proprietary LLM APIs are auditable without disclosure. The provider hashes each token's fingerprint—the concatenation of a block embedding and a token embedding—into a Merkle tree and submits the root to the auditor; the auditor samples a subset of tokens, requests their fingerprints and Merkle paths, and recomputes the root to confirm that the claimed token count corresponds to leaves that exist in the committed tree. A separately trained matching head then checks each sampled token or block against its neighbors and against the final answer, so low-effort fabricated tokens inserted to inflate the bill can be flagged as semantically irrelevant. CoIn is probabilistic and requires the provider's active cooperation, and the experiments show that at high inflation rates the auditor detects most attacks while exposing only a small fraction of the reasoning trace.

Load-bearing premise

The entire token-count check rests on the assumption that the provider's cryptographic summary of the hidden tokens is an honest reflection of what the model really generated, even though the provider is the party suspected of inflating that number.

Editorial extensions

If this is right

  • Users of reasoning-heavy APIs can demand a CoIn-style commitment and spot-check their bills without ever seeing the proprietary reasoning text.
  • Providers can keep reasoning sequences confidential while offering third-party attestation that billed tokens were real and relevant, changing the trust economics of opaque APIs.
  • The matching heads generalize to an out-of-domain benchmark in the paper, so the audit pipeline does not appear to require per-domain retraining.
  • Detection accuracy rises with inflation rate, making systematic overbilling at scale the easiest case to catch; even a 10% forgery rate still gives a 40.1% single-audit detection chance.
  • A learning-based verifier should be used when catching malicious samples is the priority, while a rule-based verifier yields fewer false alarms on benign samples.

Reading between the lines

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

  • Editorial inference: because the provider builds the cryptographic summary being verified, the quantity check is only as strong as the provider's cooperation; nothing in the protocol forces the summary to reflect the tokens the model actually generated.
  • Editorial inference: a determined attacker could pad a trace with on-topic filler—paraphrased restatements of the question or answer—that would likely pass both matching heads; the paper does not test this paraphrase-inflation case.
  • Editorial inference: the paper's reconstruction analysis shows semantically close reconstructions from exposed embeddings, so hiding the surface text does not hide the meaning; mining the reasoning content from leaked embeddings remains an open risk.
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. CoIn proposes a two-component framework for auditing invisible reasoning tokens in commercial opaque LLM APIs (COLA). The first component builds a Merkle hash tree over token-embedding fingerprints and uses Merkle proofs to verify the reported number of hidden reasoning tokens; the second trains lightweight matching heads to score token-to-block and block-to-answer semantic relevance, aiming to detect fabricated or low-effort injected tokens. The paper formalizes naive and adaptive token-count inflation, describes the CoIn protocol with algorithms, and reports experiments on five DeepSeek-R1-derived datasets claiming a detection success rate (DSR) of up to 94.7%. The central claim is that CoIn, as a trusted third-party auditor, can verify both the quantity and semantic validity of invisible reasoning tokens without exposing proprietary content.

Significance. If the protocol worked as claimed, CoIn would address a real and timely problem: billing transparency for commercial reasoning APIs. The paper also makes a useful contribution by formalizing token-count inflation as a distinct security problem and by releasing a dataset and code for studying it. The reported semantic-matching evaluations are a reasonable proof-of-concept for detecting content-level anomalies in synthetic attack settings. However, the central quantity-verification claim is unsound as stated, and the experiments do not evaluate the protocol against the actual naive inflation attack defined in Section 3. The semantic component, while interesting, does not substitute for a sound count-verification mechanism. Given that the paper's headline contribution is the ability to count invisible tokens, the identified flaws are load-bearing and cannot be repaired by local revision.

major comments (4)
  1. [§4.1, Algorithm 3] The Merkle tree is constructed by COLA, the suspected adversary, over fingerprints that COLA itself computes, and the root is submitted by COLA to the auditor. A Merkle proof verifies only that a queried fingerprint is a member of the committed leaf set; it does not bind that set to the actual reasoning trace R. In particular, a provider running the Section 3 naive attack (reporting m_f > m without modifying the output) can build a fresh tree over m_f leaves—using, for example, the duplicated-last-leaf padding of Algorithm 3 lines 25-28—and return its root. Every queried token then verifies against that root, so the protocol provides no soundness against the count-only inflation it claims to prevent. The statement in §4.1 that the Merkle proof 'ensures both the structural integrity and the correctness of the reported token count' is therefore unsupported.
  2. [§5.1, Table 1] The experimental 'Naive Inflation' is not the formal naive attack defined in Section 3. The Section 3 attack is a pure count misreport (m_f > m) with no change to the returned output. The experimental variant, however, injects random vocabulary tokens into the reasoning sequence, which is a content-forgery attack whose detection is attributable to the semantic-validity head. Consequently, the reported detection success rates, including the headline 94.7% figure, measure semantic classification on in-distribution injected content rather than the ability to detect a provider simply lying about the token count. The quantity-verification component is never tested against the attack it is designed to stop.
  3. [§5.1, Algorithm 1 and §3 threat model] The evaluation is circular relative to the claimed adversarial setting. The inflated samples used in both training and testing are generated by the same Algorithm 1 procedure, with the same anchor sources, strategies, and weights that the matching heads are trained on. The threat model of Section 3, by contrast, describes COLA as an adversary that knows the protocol and can adapt. The reported DSR is therefore in-distribution classifier accuracy, not a detection rate against an adaptive adversary. A concrete test would be to train the detector only on benign data and then evaluate on attack strategies not present in the training distribution, or to have an independent party generate held-out attacks.
  4. [§7, Limitations] The third stated limitation acknowledges that CoIn 'requires the active cooperation of COLA' and that COLA could deploy CoIn 'to attest to its own integrity.' This is in tension with the paper's framing of CoIn as a trusted third-party auditor that detects token-count inflation by a dishonest provider. As written, the protocol is a voluntary attestation scheme; it offers no cryptographic or computational binding between the committed tree and the actual model execution. Without such a binding mechanism—e.g., a trusted execution environment, provider-signed non-interactive proofs, or a secret embedded in the model that is infeasible to forge—the quantity-verification component provides no adversarial guarantee.
minor comments (5)
  1. [§4] The text says CoIn comprises 'two complimentary components'; 'complimentary' should be 'complementary.'
  2. [Figure 9 caption] The caption contains a typo: 'acorss' should be 'across.'
  3. [Algorithm 4, line 16] The pseudocode line 'Randomly select a subset of reasoning tokens {r_i}^k_{i=1} from B_j (e.g., 10' is incomplete; it should state the fraction of tokens sampled, as in Section 4.3.
  4. [Table 5 and §6] The conclusion that the LLM 'successfully preserves the core semantics' in the reconstruction experiment is stronger than the evidence supports: high BERTScore with low BLEU/ROUGE-L is consistent with paraphrase-level similarity, but the table reports no statistical significance or comparison against a retrieval-only baseline.
  5. [§2, References] The related-work section cites watermark-based and multi-agent auditing methods, but it would benefit from a brief discussion of why those techniques cannot be extended to count verification, since the paper's contribution is positioned as distinct from them.

Circularity Check

2 steps flagged · score 7.0 of 10

Token-quantity verification checks consistency with the provider's own Merkle root, so the reported count is self-verified rather than bound to the actual hidden trace; the 94.7% DSR is measured on the same synthetic inflation generator used for training.

  1. self definitional [Section 4.1, 'Fingerprint Hash Tree Construction' and 'Merkle Proof'; Algorithms 2 and 3]
    "COLA applies a cryptographic hash function (e.g., SHA-256), agreed upon with CoIn, to each token fingerprint to construct the leaf nodes of a Merkle Hash Tree ... This root serves as a commitment to the full set of reasoning tokens and is submitted to CoIn. ... CoIn recomputes the Merkle root from the provided data and checks for consistency with the original commitment by COLA provider. A successful match confirms the integrity of the selected token; a mismatch indicates possible fabrication and inflated token reporting."

    Algorithm 3 lets COLA, the suspected adversary, choose the fingerprints, build the tree, and submit the root; Algorithm 2 only checks that a queried fingerprint hashes up to that root. Because the tree is padded by duplicating the last leaf hash (Algorithm 3, lines 24-28), even the leaf count is not inferable from the tree. A provider running the Section 3 'naive token count inflation' can build a fresh tree over m_f leaves and report its root, and every Merkle proof will pass by construction. The proof therefore verifies membership in the provider-chosen set, not equality with the actual reasoning tokens R, so the claimed 'correctness of the reported token count' reduces to self-consistency with the adversary's own commitment.

  2. fitted input called prediction [Section 5.1, 'Token Inflation Implementations' and 'Datasets and Training Setup'; Section 5.2]
    "These strategies are applied to generate inflated samples for both training and evaluation. ... For the matching head, we treat original samples as normal instances and apply Naive Inflation as well as Adaptive Inflation 1 and 2 to construct inflated samples. Normal and inflated samples are labeled 0 and 1 respectively and mixed at a 1:1 ratio to form the training set."

    The headline 'detection success rate reaching up to 94.7%' is the classification accuracy of matching heads evaluated on test samples generated by the same Algorithm 1 injection variants (Table 1) used to construct their training data. The model is fitted to distinguish exactly these four synthetic attack types, so the reported DSR is an in-distribution accuracy measure, not an independent detection rate for the formal Section 3 'naive inflation' attack, which is count-only overbilling without content modification. The Math (OOD) split is out-of-distribution in domain only, not in attack type, so it does not break the training/evaluation generator overlap.

full rationale

The paper contains no load-bearing self-citations: the only imported prior construction is the standard Merkle hash tree, which is external and independent. The semantic validity verification is a genuinely trained classifier with held-out evaluation, so that component has independent empirical content. However, the central quantity claim is circular by construction. COLA itself builds the Merkle tree and submits the root, and Algorithm 2 verifies only that queried fingerprints hash to that root. Since Algorithm 3 pads by duplicating the last leaf hash and the provider controls the leaf set, a provider reporting an inflated count can build a tree with that many leaves and pass every proof. The Merkle proof therefore verifies the provider's own commitment, not the actual hidden reasoning trace, directly contradicting the paper's claim that it 'defends against naive token count inflation.' The 94.7% detection figure is also computed on evaluation samples produced by the same Algorithm 1 inflation strategies used for training, making it in-distribution classifier accuracy rather than a standalone audit of an adversarial count manipulation. Together these issues make the headline 'counting the invisible tokens' claim substantially circular, while the semantic-relevance classifier remains a separable, partially independent contribution. Score 7 reflects that the central quantity verification reduces to self-verification by definition, though not every component of the paper is circular.

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

The protocol depends on a small set of unverified assumptions about provider behavior and data representativeness. The most critical is honest construction of the token commitment, which is the very behavior the paper aims to detect. No new physical or mathematical entities are introduced.

free parameters (4)
  • Verification threshold tau = 0.5 (learning-based verifier), 0.6 (rule-based verifier)
    Threshold for accepting an audit round; chosen to trade off detection rate against false positives and tuned in Figure 4.
  • Initial sampling ratio gamma = 0.3
    Fraction of reasoning blocks selected for the first audit round; part of the protocol cost and coverage tradeoff.
  • Tokens sampled per block k = 10% of block size (0.1*beta)
    Number of token fingerprints revealed per audited block; default set in Algorithm 4.
  • Block size beta = 256, 512, 1024 in sweeps
    Partitions reasoning traces into blocks; affects exposure, cost, and detection performance (Table 2, Figures 7-10).
assumptions (5)
  • standard math Cryptographic hash functions are collision-resistant and binding
    Used to construct the Merkle tree and verify token fingerprints (Section 4.1).
  • domain assumption The auditor-fixed embedding model produces stable, semantically meaningful embeddings of tokens and blocks
    Both the hash tree and the matching heads operate on these embeddings; if embeddings are unstable or manipulable, the audit is meaningless (Section 4.1).
  • domain assumption The provider honestly computes embeddings of the true reasoning trace with the auditor-fixed model
    The threat model in Section 3 says COLA controls the computation; the protocol only works if the provider follows the protocol, as acknowledged in Section 7. The commitment does not bind the provider to real inference.
  • domain assumption Synthetic inflation attacks (naive and adaptive 1-4) are representative of real-world token inflation
    Training and evaluation of the matching heads use these synthetic attacks (Table 1, Appendix A); detection performance on naturally occurring inflation is untested.
  • domain assumption DeepSeek-R1 reasoning traces approximate the hidden reasoning of commercial opaque APIs
    All datasets are distilled from DeepSeek-R1 (Section 5.1); no experiment runs on an actual commercial API with hidden reasoning.

how reviews work

0 comments
Cite this review

Pith. "Pith review of CoIn: Counting the Invisible Reasoning Tokens in Commercial Opaque LLM APIs." pith.science (2026). https://pith.science/paper/UP3CPV47

@misc{pith2026250513778,
  author       = {Pith},
  title        = {Pith review of: CoIn: Counting the Invisible Reasoning Tokens in Commercial Opaque LLM APIs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/UP3CPV47}},
  note         = {Machine review of arXiv:2505.13778}
}
read the original abstract

As post-training techniques evolve, large language models (LLMs) are increasingly augmented with structured multi-step reasoning abilities, often optimized through reinforcement learning. These reasoning-enhanced models outperform standard LLMs on complex tasks and now underpin many commercial LLM APIs. However, to protect proprietary behavior and reduce verbosity, providers typically conceal the reasoning traces while returning only the final answer. This opacity introduces a critical transparency gap: users are billed for invisible reasoning tokens, which often account for the majority of the cost, yet have no means to verify their authenticity. This opens the door to token count inflation, where providers may overreport token usage or inject synthetic, low-effort tokens to inflate charges. To address this issue, we propose CoIn, a verification framework that audits both the quantity and semantic validity of hidden tokens. CoIn constructs a verifiable hash tree from token embedding fingerprints to check token counts, and uses embedding-based relevance matching to detect fabricated reasoning content. Experiments demonstrate that CoIn, when deployed as a trusted third-party auditor, can effectively detect token count inflation with a success rate reaching up to 94.7%, showing the strong ability to restore billing transparency in opaque LLM services. The dataset and code are available at https://github.com/CASE-Lab-UMD/LLM-Auditing-CoIn.

Figures

Figures reproduced from arXiv: 2505.13778 by the authors.

Figure 1
Figure 1. Ratio of reasoning tokens to answer tokens across datasets and deployed APIs. (a) Token [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. CoIn Framework. 4 CoIn: Counting the Invisible Reasoning Tokens CoIn comprises two complimentary components: token quantity verification and semantic validity verification. The token quantity verification module treats embeddings of invisible reasoning tokens as cryptographic fingerprints and organizes them into a verifiable hash tree. By querying a small subset of these fingerprints, users can audit the claimed num… view at source ↗
Figure 3
Figure 3. Performance of CoIn across different inflation methods and verifiers. The red lines and the blue lines represent the DSR of rule-based verifier and learning-based verifier, respectively. γ For the block-to-answer verification task, we adopt a similar setup, but use Ada. Inflation 1–4 to construct inflated samples. This setting enables a thorough evaluation of the model’s ability to detect both shallow and semantical… view at source ↗
Figures from the paper (8 more)
Figure 4
Figure 4. Figure 4: Impact of threshold τ on DSR. β, ℓ decreases, indicating lower cost. However, AER increases, and the results in Appendix E show that increasing the block size reduces the DSR for adaptive inflation. 5.3 Performance of the Semantic Validity Verification Block-to-Answer …
Figure 5
Figure 5. Figure 5: Merkle Tree Construction Time with Fluctuation Range [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 7
Figure 7. Figure 7: Performance of CoIn across different inflation methods and verifiers (Block Size = 512). The red lines and the blue lines represent the DSR of rule-based verifier and learning-based verifier, respectively. γ [PITH_FULL_IMAGE:figures/full_fig_p017_7.png]
Figure 8
Figure 8. Figure 8: Impact of threshold τ on DSR (Block Size = 512). E Detection Performance of CoIn We show the comparison of the two verifiers and the impact of τ under different block sizes, as shown in [PITH_FULL_IMAGE:figures/full_fig_p017_8.png]
Figure 9
Figure 9. Figure 9: Performance of CoIn acorss different inflation methods and verifiers (Block Size = 1024). The red lines and the blue lines represent the DSR of rule-based verifier and learning-based verifier, respectively. γ [PITH_FULL_IMAGE:figures/full_fig_p018_9.png]
Figure 10
Figure 10. Figure 10: Impact of threshold τ on DSR (Block Size = 1024). 18 [PITH_FULL_IMAGE:figures/full_fig_p018_10.png]
Figure 11
Figure 11. Figure 11: Prompt for Recovering a Hidden Reasoning Passage Using Question, Answer, Token [PITH_FULL_IMAGE:figures/full_fig_p019_11.png]
Figure 12
Figure 12. Figure 12: Prompt for Judging Whether a Block Supports or Explains a Final Answer. [PITH_FULL_IMAGE:figures/full_fig_p020_12.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

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

  1. Hollow-LLM Attack: Computationally Trivial Weights in Zero-Knowledge Verification of LLM Inference

    cs.CR 2026-07 conditional novelty 6.0 of 10

    ZK-verified LLM inference can be fooled: a provider can serve a small model while producing valid proofs for a much larger declared model by embedding structure-preserving ghost weights.

  2. Pay for The Second-Best Service: A Game-Theoretic Approach Against Dishonest LLM Providers

    cs.GT 2025-11 conditional novelty 6.0 of 10

    A delegation mechanism makes near-truthful behavior approximately dominant for LLM API providers, and a matching impossibility result caps user utility at the second-best honest service.

Reference graph

Works this paper leans on

34 extracted references · 4 canonical work pages · cited by 2 Pith papers

  1. [1]

    Are you getting what you pay for? auditing model substitution in llm apis

    Will Cai, Tianneng Shi, Xuandong Zhao, and Dawn Song. Are you getting what you pay for? auditing model substitution in llm apis. arXiv preprint arXiv:2504.04715, 2025

    arXiv 2025

  2. [2]

    Huatuogpt-o1, towards medical complex reasoning with llms, 2024

    Junying Chen, Zhenyang Cai, Ke Ji, Xidong Wang, Wanlong Liu, Rongsheng Wang, Jianye Hou, and Benyou Wang. Huatuogpt-o1, towards medical complex reasoning with llms, 2024. URL https://arxiv.org/abs/2412.18925

    arXiv 2024

  3. [4]

    Open r1: A fully open reproduction of deepseek-r1, January 2025

    Hugging Face. Open r1: A fully open reproduction of deepseek-r1, January 2025. URL https://github.com/huggingface/open-r1

    2025

  4. [5]

    Pal: Program-aided language models

    Xingcheng Gao, Swaroop Mishra, et al. Pal: Program-aided language models. arXiv preprint arXiv:2211.10435, 2023

    arXiv 2023

  5. [6]

    Knowledge distillation: A survey

    Jianping Gou, Baosheng Yu, Stephen J Maybank, and Dacheng Tao. Knowledge distillation: A survey. International Journal of Computer Vision, 129 0 (6): 0 1789--1819, 2021

    2021

  6. [7]

    Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948, 2025

    arXiv 2025

  7. [8]

    Llm reasoners: New evaluation, library, and analysis of step-by-step reasoning with large language models

    Shibo Hao, Yi Gu, Haotian Luo, Tianyang Liu, Xiyan Shao, Xinyuan Wang, Shuhua Xie, Haodi Ma, Adithya Samavedhi, Qiyue Gao, et al. Llm reasoners: New evaluation, library, and analysis of step-by-step reasoning with large language models. arXiv preprint arXiv:2404.05221, 2024

    arXiv 2024

  8. [9]

    Llm-adapters: An adapter family for parameter-efficient fine-tuning of large language models

    Zhiqiang Hu, Lei Wang, Yihuai Lan, Wanyu Xu, Ee-Peng Lim, Lidong Bing, Xing Xu, Soujanya Poria, and Roy Ka-Wei Lee. Llm-adapters: An adapter family for parameter-efficient fine-tuning of large language models. arXiv preprint arXiv:2304.01933, 2023

    arXiv 2023

Show all 34 references
  1. [10]

    Openai o1 system card

    Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al. Openai o1 system card. arXiv preprint arXiv:2412.16720, 2024

    2024 arXiv

  2. [11]

    The impact of reasoning step length on large language models

    Mingyu Jin, Qinkai Yu, Dong Shu, Haiyan Zhao, Wenyue Hua, Yanda Meng, Yongfeng Zhang, and Mengnan Du. The impact of reasoning step length on large language models. arXiv preprint arXiv:2401.04925, 2024

    2024 arXiv

  3. [12]

    Llm post-training: A deep dive into reasoning large language models

    Komal Kumar, Tajamul Ashraf, Omkar Thawakar, Rao Muhammad Anwer, Hisham Cholakkal, Mubarak Shah, Ming-Hsuan Yang, Phillip HS Torr, Fahad Shahbaz Khan, and Salman Khan. Llm post-training: A deep dive into reasoning large language models. arXiv preprint arXiv:2502.21321, 2025

    2025 arXiv

  4. [13]

    Llms-as-judges: a comprehensive survey on llm-based evaluation methods

    Haitao Li, Qian Dong, Junjie Chen, Huixue Su, Yujia Zhou, Qingyao Ai, Ziyi Ye, and Yiqun Liu. Llms-as-judges: a comprehensive survey on llm-based evaluation methods. arXiv preprint arXiv:2412.05579, 2024

    2024 arXiv

  5. [14]

    Rouge: A package for automatic evaluation of summaries

    Chin-Yew Lin. Rouge: A package for automatic evaluation of summaries. In Text summarization branches out, pages 74--81, 2004

    2004

  6. [15]

    Auditing language models for hidden objectives

    Samuel Marks, Johannes Treutlein, Trenton Bricken, Jack Lindsey, Jonathan Marcus, Siddharth Mishra-Sharma, Daniel Ziegler, Emmanuel Ameisen, Joshua Batson, Tim Belonax, et al. Auditing language models for hidden objectives. arXiv preprint arXiv:2503.10965, 2025

    2025 arXiv

  7. [16]

    A digital signature based on a conventional encryption function

    Ralph C Merkle. A digital signature based on a conventional encryption function. In Conference on the theory and application of cryptographic techniques, pages 369--378. Springer, 1987

    1987

  8. [17]

    s1: Simple test-time scaling

    Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Cand \`e s, and Tatsunori Hashimoto. s1: Simple test-time scaling. arXiv preprint arXiv:2501.19393, 2025

    2025 arXiv

  9. [18]

    Bleu: a method for automatic evaluation of machine translation

    Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, pages 311--318, 2002

    2002

  10. [19]

    Direct preference optimization: Your language model is secretly a reward model

    Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model. Advances in Neural Information Processing Systems, 36: 0 53728--53741, 2023

    2023

  11. [20]

    Group robust preference optimization in reward-free rlhf

    Shyam Sundhar Ramesh, Yifan Hu, Iason Chaimalas, Viraj Mehta, Pier Giuseppe Sessa, Haitham Bou Ammar, and Ilija Bogunovic. Group robust preference optimization in reward-free rlhf. Advances in Neural Information Processing Systems, 37: 0 37100--37137, 2024

    2024

  12. [21]

    Sentence-bert: Sentence embeddings using siamese bert-networks

    Nils Reimers and Iryna Gurevych. Sentence-bert: Sentence embeddings using siamese bert-networks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 11 2019. URL https://arxiv.org/abs/1908.10084

    2019 arXiv

  13. [22]

    Scaling llm test-time compute optimally can be more effective than scaling model parameters

    Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024

    2024 arXiv

  14. [23]

    Llm pruning and distillation in practice: The minitron approach

    Sharath Turuvekere Sreenivas, Saurav Muralidharan, Raviraj Joshi, Marcin Chochowski, Ameya Sunil Mahabaleshwarkar, Gerald Shen, Jiaqi Zeng, Zijia Chen, Yoshi Suhara, Shizhe Diao, et al. Llm pruning and distillation in practice: The minitron approach. arXiv preprint arXiv:2408....

    2024 arXiv

  15. [24]

    Open Thoughts , January 2025

    Open Thoughts Team. Open Thoughts , January 2025

    2025

  16. [25]

    Self-consistency improves chain of thought reasoning in language models

    Xuezhi Wang, Jason Wei, Dale Schuurmans, et al. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171, 2022

    2022 arXiv

  17. [26]

    Chain-of-thought prompting elicits reasoning in large language models

    Jason Wei, Xuezhi Wang, Dale Schuurmans, et al. Chain-of-thought prompting elicits reasoning in large language models. arXiv preprint arXiv:2201.11903, 2022

    2022 arXiv

  18. [27]

    Pairwise proximal policy optimization: Harnessing relative feedback for llm alignment

    Tianhao Wu, Banghua Zhu, Ruoyu Zhang, Zhaojin Wen, Kannan Ramchandran, and Jiantao Jiao. Pairwise proximal policy optimization: Harnessing relative feedback for llm alignment. arXiv preprint arXiv:2310.00212, 2023

    2023 arXiv

  19. [28]

    Understanding aha moments: from external observations to internal mechanisms

    Shu Yang, Junchao Wu, Xin Chen, Yunze Xiao, Xinyi Yang, Derek F Wong, and Di Wang. Understanding aha moments: from external observations to internal mechanisms. arXiv preprint arXiv:2504.02956, 2025

    2025 arXiv

  20. [29]

    Trust, but verify

    Michael J Yuan, Carlos Campoy, Sydney Lai, James Snewin, and Ju Long. Trust, but verify. arXiv preprint arXiv:2504.13443, 2025

    2025 arXiv

  21. [30]

    Deep sets

    Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Russ R Salakhutdinov, and Alexander J Smola. Deep sets. Advances in neural information processing systems, 30, 2017

    2017

  22. [31]

    Lightthinker: Thinking step-by-step compression

    Jintian Zhang, Yuqi Zhu, Mengshu Sun, Yujie Luo, Shuofei Qiao, Lun Du, Da Zheng, Huajun Chen, and Ningyu Zhang. Lightthinker: Thinking step-by-step compression. arXiv preprint arXiv:2502.15589, 2025

    2025

  23. [32]

    Bertscore: Evaluating text generation with bert

    Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q Weinberger, and Yoav Artzi. Bertscore: Evaluating text generation with bert. arXiv preprint arXiv:1904.09675, 2019

    1904 arXiv

  24. [33]

    Judging llm-as-a-judge with mt-bench and chatbot arena

    Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in Neural Information Processing Systems, 36: 0 46595--46623, 2023

    2023

  25. [34]

    Calm: Curiosity-driven auditing for large language models

    Xiang Zheng, Longxiang Wang, Yi Liu, Xingjun Ma, Chao Shen, and Cong Wang. Calm: Curiosity-driven auditing for large language models. arXiv preprint arXiv:2501.02997, 2025

    2025 arXiv

  26. [35]

    Rethinking pre-training and self-training

    Barret Zoph, Golnaz Ghiasi, Tsung-Yi Lin, Yin Cui, Hanxiao Liu, Ekin Dogus Cubuk, and Quoc Le. Rethinking pre-training and self-training. Advances in neural information processing systems, 33: 0 3833--3845, 2020

    2020

Pith tools

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