Pith. sign in

REVIEW 4 major objections 4 minor 39 references

The first-best LLM provider is provably unreachable under strategic behavior, but a four-phase mechanism guarantees second-best service with sublinear loss.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-04 00:26 UTC pith:PYSYCSVA

load-bearing objection A genuinely novel mechanism-design model for dishonest LLM providers, but the proof of the headline user-utility guarantee counts payments as user utility and needs a fix before the central theorem is credible. the 4 major comments →

arxiv 2511.00847 v5 pith:PYSYCSVA submitted 2025-11-02 cs.GT cs.AI

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

Yuhan Cao , Yu Wang , Sitong Liu , Miao Li , Yixin Tao , Tianxing He This is my paper
classification cs.GT cs.AI
keywords mechanism designlarge language modelsincentive compatibilitysecond-best utilityonline learningcost controltoken inflationAPI providers
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

This paper asks what a user can guarantee when large language model providers can secretly substitute cheaper models or pad token counts. It models the user's T queries as a repeated game and shows that no incentive-compatible mechanism can force providers to deliver the first-best model — some positive weight on the first-best utility is impossible. Instead, the paper designs a four-phase mechanism that makes near-honest behavior a dominant strategy for every provider and guarantees the user the second-best utility, minus a sublinear approximation error O(T^{1-epsilon} log T + T^{2 epsilon}). The mechanism works by paying providers enough in two 'blind trust' phases to make truthful exploration and second-best exploitation the most profitable course. Simulation with real API prices and models confirms the prescribed strategy is the most profitable for the best provider.

Core claim

The central claim is that for any epsilon in (0,1/2), Mechanism 1 is O(T^{1-epsilon} log T)-approximately incentive compatible and yields expected user utility at least u_SB - O(T^{1-epsilon} log T + T^{2 epsilon}), where u_SB is the second-best user utility (the best achievable by the second-ranked provider under truthful behavior). The companion impossibility theorem states that no o(T)-approximately incentive compatible mechanism can guarantee xi u_FB + (1-xi) u_SB for any xi in (0,1), so the first-best provider's truthful service is unreachable in a way that a positive fraction of the first-best advantage can never be harvested. The mechanism's prescribed provider strategy is: be truthfu

What carries the argument

Mechanism 1 is a four-phase delegation protocol. The exploration phase sends B = T^{2 epsilon} queries to each provider to estimate their reward and token length; the exploitation phase selects the empirically best provider and sends it roughly T queries with a running performance check whose tolerance is O(T^{-epsilon} log T); the two blind trust phases then give every provider a fixed batch of unmonitored queries that they can exploit maximally. The blind trust phases are the load-bearing incentive: they shift the provider's payoff so that truthful exploration and second-best exploitation maximize total utility, and the proof uses backward induction. Formally, each provider's cost-performa

Load-bearing premise

Each provider's private cost-performance tradeoff must satisfy two derivative conditions — higher cost must improve user reward fast enough relative to its price, and the provider's own optimal billing adjustment must stay nonnegative — and both the provider and the mechanism must know these curves exactly; if any of that fails, the claimed dominant strategy collapses.

What would settle it

Construct two providers whose cost-performance functions violate the condition d h_i/dc - p_i d g_i/dc >= gamma (e.g., a provider where the most expensive model is worse for the user than a cheaper one), run Mechanism 1 for large T, and observe whether the provider's prescribed 'be truthful in exploration, second-best in exploitation' strategy is still the utility-maximizing one; if a deviating strategy beats it by more than O(T^{1-epsilon} log T), the theorem is false.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • API aggregators and enterprise users can adopt the mechanism as a contract: they will never get the single best model's full value, but they get the second-best provider's value minus a sublinear penalty that shrinks as T grows.
  • Any attempt to design a mechanism that combines a positive fraction of first-best utility with second-best utility is impossible; the second-best benchmark is the correct target.
  • Providers' optimal play is explicitly characterized, so the mechanism yields predictable user utility without needing to detect cheating in individual responses.
  • The approximation error O(T^{1-epsilon} log T + T^{2 epsilon}) can be tuned via epsilon, giving a trade-off between exploration cost and incentive slack.
  • The impossibility result applies to all o(T)-approximately incentive compatible mechanisms, so the bound is not an artifact of the specific four-phase design.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the two monotonicity assumptions on h_i and g_i are hard to verify in practice, an immediately testable extension is to measure how often providers deviate when cost-performance curves are near the boundary; the paper's guarantee would likely degrade gracefully only if the assumptions are approximately satisfied.
  • The blind-trust payoffs resemble a bonus contract; a natural economic reading is that the user pays a 'premium' for commitment, and one could quantify this premium as the cost of the blind trust phases relative to a hypothetical trusted provider.
  • The impossibility theorem suggests that any detection-based auditing system, however accurate, cannot recover the first-best outcome in this model; the fundamental barrier is incentive compatibility, not observability.
  • A concrete empirical test: run the mechanism against live API providers with deliberately distorted cost-reporting incentives (e.g., a provider that can choose among models with non-monotonic quality) and check whether the performance check in the exploitation phase triggers earlier than predicted.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 4 minor

Summary. The paper introduces a repeated Stackelberg game between a user issuing T queries and K strategic LLM API providers who can secretly cut cost/quality and inflate reported token lengths. It proposes Mechanism 1 (exploration, exploitation, two blind-trust phases) and claims, under differential assumptions on each provider's cost-performance functions h_i(c), g_i(c), that the mechanism is O(T^{1-epsilon} log T)-approximately incentive compatible and guarantees user utility at least u_SB - O(T^{1-epsilon} log T + T^{2 epsilon}). It also claims an impossibility theorem (Theorem 5.1) that no o(T)-approximately incentive-compatible mechanism can guarantee a first-best blend of user utilities. The appendix contains the proofs and Section 6 reports simulations using real-world API prices and NLGraph.

Significance. If the results were correct, this would be a useful contribution to mechanism design for LLM APIs: a clean formal model, a novel four-phase mechanism, an explicit impossibility result, and finite-T guarantees. The mechanism is self-contained and its parameters are explicit rather than fitted, which are strengths. However, the two central proofs as written contain serious gaps: Theorem 5.3's proof misaccounts user utility by counting blind-trust payments as positive utility, and Theorem 5.1's proof contains an algebraic error that prevents the claimed contradiction. The paper also omits the proof of a load-bearing lemma and leaves an editing artifact in the proof of Theorem 5.2. These issues mean the main claims are not established in the current version, although they may be repairable.

major comments (4)
  1. [Appendix A.2, proof of Theorem 5.3] The displayed lower bound is not justified by the model. The third summand, sum_i (2 mu_i^r/(p_i L) - 2 mu_i^l/L + 3) p_i B L, is the total payment made to providers in blind-trust phase II, not the user's utility. Under the strategy prescribed in Theorem 5.2, providers in blind-trust phases incur zero cost and report length L; the user's utility for each such query is h_i(0)-p_i L, which is generally negative rather than +p_i L. Blind-trust phase I queries are omitted from the bound entirely. Since user utility is defined in Section 3.1 as reward minus payment, the inequality 'user utility >= ...' does not follow. A corrected accounting must include the negative O(T^{2 epsilon}) blind-trust terms; because the theorem's slack already contains O(T^{2 epsilon}), the statement may be repairable, but the proof as written is invalid.
  2. [Appendix A.1, proof of Theorem 5.1] There is an algebra error in the derivation of the recurrence for x_j. Since u(j)-u^circ = j/(2N), dividing the term j lambda/N by u(j)-u^circ gives 2 lambda, not lambda and not j lambda/N. With lambda = xi/2 as set in the proof, the correct recurrence is x_j >= (1/j) sum_{k<j} x_k, whose induction gives only x_j >= x_1/j. The claimed lower bound x_j >= (xi - j lambda/N) sum 1/k, and hence the contradiction x_N > 1, does not follow. The proof must be repaired (e.g., by choosing lambda < xi/2 and N > exp(1/(xi-2 lambda)) and adjusting the construction) or the impossibility claim is unproven.
  3. [Appendix A.2, Lemma A.1; Section 5.2, proof of Theorem 5.2] Lemma A.1, which states that the total number of completed queries is at most T, is accompanied only by 'We omit this proof due to lack of space.' This is a load-bearing invariant: if the blind-trust phase II allocations can exceed the remaining budget, the T-query horizon is violated and all subsequent guarantees fail. In addition, the proof of Theorem 5.2 contains the editing artifact 'we do not repeat it here due to lack of space' immediately before the proof appears. These omissions make the appendix impossible to verify as submitted.
  4. [Section 6.1] The paper states 'We verify that the assumptions discussed at the beginning of this section are satisfied' but provides no details or data. Since Theorem 5.2's dominant-strategy conclusion is conditional on the two differential inequalities d h_i/dc - p_i d g_i/dc >= gamma and d h_i/dc - c d g_i/dc - g_i >= 0, the verification is essential for interpreting Figure 2 as evidence for the proposed strategy. Please report the estimated h_i and g_i (or the discrete analogues) and the values of these expressions for the providers used in the experiments.
minor comments (4)
  1. [Appendix A.2, proof of Theorem 5.2] The text says the overall maximum is attained at 'alpha_i = 1'; this should be alpha_i = p_i, the truthful cost.
  2. [Mechanism 1, line 15; proof of Theorem 5.2] The symbol b is used in the validation threshold (b+p_i L)M/3 and in Hoeffding's inequality but is never defined. Presumably it is the reward range R; please define it in the input list.
  3. [Section 6, Figures 2-4] The simulation figures report point estimates without error bars, confidence intervals, or variance. Because Mechanism 1 includes randomized fractional delegation (line 28) and the authors sample from 2,000 fixed responses, some measure of variability is needed to support the claimed optimality of the proposed strategy.
  4. [Section 5.2, Theorem 5.2] The proof of Theorem 5.2 relies on the two differential assumptions not only in the exploration phase but also in Lemma A.2 for the exploitation phase; this dependence should be made explicit where Lemma A.2 is stated.

Circularity Check

0 steps flagged

No significant circularity: the mechanism is a transparent construction, and the only author-overlapping citation is a dataset reference that is not load-bearing.

full rationale

The paper's central claims are not circular. Mechanism 1 constructs delta_i from exploration estimates and uses it only to allocate blind-trust-II queries; this is a transparent payment rule, not a fitted constant subsequently called a prediction. Theorem 5.2 verifies by backward induction that truthful exploration is approximately optimal under the stated monotonicity assumptions; those assumptions are given in the theorem and are not derived from the conclusion. Theorem 5.1 is proved from the incentive constraints of the constructed type sets, and the second-best benchmark u_SB is defined externally from provider characteristics; the exploitation phase then contractually requires i* to deliver at least an estimate of the second-best utility. The equality in the proof of Theorem 5.3 is the intended consequence of the contract, not an input smuggled in as a result. The only author-overlapping citation is [33] (NLGraph dataset), which is used for experiments only and is not load-bearing for any theorem. No uniqueness theorem or prior-work ansatz is imported. I therefore find no circular step. I do flag, as non-circular concerns: (1) The displayed lower bound in Theorem 5.3 adds sum_i (2 mu^r_i/(p_i L) - 2 mu^l_i/L + 3) p_i B L, which is the blind-trust-II payment under the Theorem 5.2 strategy; since user utility is defined as reward minus payment, this term cannot be added with a positive sign as written. That is a proof-error/correctness gap, not equivalence by construction. (2) Section 7 states the mechanism "requires all providers to have complete prior knowledge of the model's capabilities," Section 6.1 only says "We verify that the assumptions discussed at the beginning of this section are satisfied" without giving the verification, and Lemma A.1's proof is omitted "due to lack of space." These are completeness limitations and do not make the derivation circular.

Axiom & Free-Parameter Ledger

4 free parameters · 11 axioms · 0 invented entities

No new physical entities are introduced. The model constructs (belief functions h_i, g_i, blind-trust phases, second-best benchmark) are analytical devices, not entities with independent falsifiable handles. The main free design parameters are epsilon, L, B, and M; the latter two are derived from epsilon rather than separately fitted.

free parameters (4)
  • epsilon = 0.3 in simulation; any epsilon in (0,1/2) in theory
    Controls the trade-off: exploration size B=T^{2 epsilon} and threshold width M=T^{-epsilon} ln(KT). Not fitted to data, but the approximation rate depends on it.
  • L (maximum output token length) = 38,058 in simulation
    Bound on all token sequence lengths. In experiments it is set to the max length in the 2,000 sampled LLM outputs, so it is data-dependent; the theory treats L as a known constant.
  • B = T^{2 epsilon}
    Batch size per provider in the exploration and blind-trust phases. It is directly determined by epsilon, not independently estimated.
  • M = T^{-epsilon} ln(KT)
    Relaxation margin for the exploitation-phase utility check. Determined by epsilon, K, and T; not fitted to data.
axioms (11)
  • domain assumption Provider utility of truthful behavior is zero, and misreporting token sequences has negligible cost.
    Section 3.1 defines provider utility as p_i |tau'_t| - c_t |tau_t|; this zero-truth baseline drives all incentive calculations.
  • domain assumption Continuous strategy space: cost c_t and reported length |tau'_t| are real numbers.
    Acknowledged in Section 3.1 as a mathematical convenience; footnote 3 says the discrete setting adds an O(T) token-cost error.
  • domain assumption For each provider, cost-performance functions h_i and g_i exist, are Lipschitz, and satisfy the two derivative inequalities in Theorem 5.2.
    These are private beliefs; if they fail, the prescribed strategy is not O(T^{1-epsilon} log T)-dominant. Section 6.1 only asserts they are verified.
  • domain assumption Every provider has complete prior knowledge of model capabilities.
    Stated in Section 7 Limitation; needed so providers can compute the second-best strategy during the exploitation phase.
  • domain assumption Providers do not collude, and the user or mechanism designer behaves truthfully.
    Stated in Section 7 Limitation; collusion could coordinate first- and second-best providers, and misreporting B would break exploration.
  • domain assumption Token sequence length is bounded by L and reward by R.
    Used for Hoeffding concentration bounds and phase allocations in Mechanism 1.
  • domain assumption The user can credibly commit to the announced mechanism (Stackelberg leader).
    Section 3.1: the user commits to and announces a delegation mechanism at the start.
  • domain assumption Queries are sampled i.i.d. from dataset D.
    Expectations in utility definitions and concentration arguments rely on independent sampling of prompts.
  • domain assumption Cost of processing the input prompt is ignored.
    Remark 1 in Section 3.1; assumed to be handled similarly or to be negligible.
  • standard math Hoeffding's inequality applies to bounded rewards and token lengths.
    Used in the Theorem 5.2 proof to control deviations of running averages in the exploitation phase.
  • standard math Lipschitz functions on compact domains have bounded partial derivatives and are Lipschitz continuous in the objective.
    Used in Lemma A.2 to bound the gap between the relaxed and exact optimization programs.

pith-pipeline@v1.3.0-alltime-deepseek · 18741 in / 16020 out tokens · 165914 ms · 2026-08-04T00:26:30.891919+00:00 · methodology

0 comments
read the original abstract

The widespread adoption of Large Language Models (LLMs) through Application Programming Interfaces (APIs) induces a critical vulnerability: the potential for dishonest manipulation by service providers. This manipulation can manifest in various forms, such as secretly substituting a proclaimed high-performance model with a low-cost alternative, or inflating responses with meaningless tokens to increase billing. This work tackles the issue through the lens of algorithmic game theory and mechanism design. We are the first to propose a formal economic model for a realistic user-provider ecosystem, where a user can iteratively delegate $T$ queries to multiple model providers, and providers can engage in a range of strategic behaviors. As our central contribution, we prove that for a continuous strategy space and any $\epsilon\in(0,\frac12)$, there exists an approximate incentive-compatible mechanism with an additive approximation ratio of $O(T^{1-\epsilon}\log T)$, and a guaranteed quasi-linear second-best user utility. We also prove an impossibility result, stating that no mechanism can guarantee an expected user utility that is asymptotically better than our mechanism. Furthermore, we demonstrate the effectiveness of our mechanism in simulation experiments with real-world API settings.

Figures

Figures reproduced from arXiv: 2511.00847 by Miao Li, Sitong Liu, Tianxing He, Yixin Tao, Yuhan Cao, Yu Wang.

Figure 1
Figure 1. Figure 1: An illustration figure of our proposed mechanism, in which the provider’s optimal strategy would guarantee the [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Simulation experiment where each provider enumerates strategies listed in Table 1. provider 1’s expected provider [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Average provider utility, user utility (from each provider), and number of delegations for provider 2 and provider 3 [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: User utility of provider 1 as 𝑇 increases from 1 million to 2 million. We also plot a theoretical reference, 𝑢𝑆𝐵 (defined in Section 3). utility). Consequently, the provider utility for this strategy is per￾petually zero. In contrast, the dishonest-all strategy perpetually employs the worst LLM and bills for the maximum possible token length. We further consider two more sophisticated dishonest strate￾gies… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

39 extracted references · 2 canonical work pages

  1. [1]

    Introducing Claude 4

    2025. Introducing Claude 4. https://www.anthropic.com/news/claude-4

    2025

  2. [2]

    Introducing gpt-5

    2025. Introducing gpt-5. https://openai.com/index/introducing-gpt-5/

    2025

  3. [3]

    Mislav Balunović, Jasper Dekoninck, Ivo Petrov, Nikola Jovanović, and Martin Vechev. 2025. Matharena: Evaluating llms on uncontaminated math competitions. arXiv preprint arXiv:2505.23281(2025)

    Pith/arXiv arXiv 2025

  4. [4]

    Dirk Bergemann, Alessandro Bonatti, and Alex Smolin. 2025. The Economics of Large Language Models: Token Allocation, Fine-Tuning, and Optimal Pricing. arXiv:2502.07736 [econ.TH] https://arxiv.org/abs/2502.07736

    arXiv 2025

  5. [5]

    Djallel Bouneffouf and Raphael Feraud. 2025. Survey: Multi-Armed Bandits Meet Large Language Models. arXiv:2505.13355 [cs.AI] https://arxiv.org/abs/2505. 13355

    arXiv 2025

  6. [6]

    Mark Braverman, Jieming Mao, Jon Schneider, and S Matthew Weinberg. 2019. Multi-armed bandit problems with strategic arms. InConference on Learning Pay for The Second-Best Service: A Game-Theoretic Approach Against Dishonest LLM Providers WWW ’26, April 13-17, 2026, Dubai, United Arab Emirates Theory. PMLR, 383–416

    2019

  7. [7]

    Will Cai, Tianneng Shi, Xuandong Zhao, and Dawn Song. 2025. Are You Getting What You Pay For? Auditing Model Substitution in LLM APIs. arXiv:2504.04715 [cs.CL] https://arxiv.org/abs/2504.04715

    arXiv 2025

  8. [8]

    Lingjiao Chen, Matei Zaharia, and James Zou. 2023. How is ChatGPT’s behavior changing over time? arXiv:2307.09009 [cs.CL] https://arxiv.org/abs/2307.09009

    Pith/arXiv arXiv 2023

  9. [9]

    Y Chen, L Li, and Y Zhang. 2024. Exploration–Exploitation in LLM Decoding: An𝜖-Greedy Approach with Regret Guarantees.arXiv preprint arXiv:2403.01168 (2024)

    Pith/arXiv arXiv 2024

  10. [10]

    DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, et al. 2025. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv:2501.12948 [cs.CL] https://arxiv.org/ abs/2501.12948

    Pith/arXiv arXiv 2025

  11. [11]

    Paul Dütting, Michal Feldman, and Inbal Talgam-Cohen. 2025. Algorithmic Contract Theory: A Survey.Found. Trends Theor. Comput. Sci.16, 3–4 (Dec. 2025), 211–412. doi:10.1561/0400000113

    work page doi:10.1561/0400000113 2025

  12. [12]

    Paul Dütting, Vahab Mirrokni, Renato Paes Leme, Haifeng Xu, and Song Zuo. 2024. Mechanism Design for Large Language Models. InProceedings of the ACM Web Conference 2024(Singapore, Singapore)(WWW ’24). Association for Computing Machinery, New York, NY, USA, 144–155. doi:10.1145/3589334.3645511

    arXiv 2024

  13. [13]

    Sabri Eyuboglu, Karan Goel, Arjun Desai, Lingjiao Chen, Mathew Monfort, Chris Ré, and James Zou. 2024. Model ChangeLists: Characterizing Updates to ML Models. InProceedings of the 2024 ACM Conference on Fairness, Accountability, and Transparency(Rio de Janeiro, Brazil)(FAccT ’24). Association for Computing Machinery, New York, NY, USA, 2432–2453. doi:10.1...

    arXiv 2024

  14. [14]

    Irena Gao, Percy Liang, and Carlos Guestrin. 2025. Model Equality Testing: Which Model is this API Serving?. InThe Thirteenth International Conference on Learning Representations. https://openreview.net/forum?id=QCDdI7X3f9

    2025

  15. [15]

    Ruihao Gong, Yifu Ding, Zining Wang, Chengtao Lv, Xingyu Zheng, Jinyang Du, Haotong Qin, Jinyang Guo, Michele Magno, and Xianglong Liu. 2024. A Survey of Low-bit Large Language Models: Basics, Systems, and Algorithms. arXiv:2409.16694 [cs.AI] https://arxiv.org/abs/2409.16694

    arXiv 2024

  16. [16]

    Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and Jürgen Schmidhuber

  17. [17]

    Abhinav Kumar, Jaechul Roh, Ali Naseh, Marzena Karpinska, Mohit Iyyer, Amir Houmansadr, and Eugene Bagdasarian. 2025. OverThink: Slowdown Attacks on Reasoning LLMs. arXiv:2502.02542 [cs.LG] https://arxiv.org/abs/2502.02542

    arXiv 2025

  18. [18]

    Benjamin Laufer, Jon Kleinberg, and Hoda Heidari. 2024. Fine-Tuning Games: Bargaining and Adaptation for General-Purpose Models. InProceedings of the ACM Web Conference 2024(Singapore, Singapore)(WWW ’24). Association for Computing Machinery, New York, NY, USA, 66–76. doi:10.1145/3589334.3645366

    arXiv 2024

  19. [19]

    Qijun Miao and Zhixuan Fang. 2025. User-side Model Consistency Monitoring for Open Source Large Language Models Inference Services. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Wanxiang Che, Joyce Nabende, Ekaterina Shutova, and Moham- mad Taher Pilehvar (Eds.). Association for Computat...

    work page doi:10.18653/v1/2025.acl-long.569 2025

  20. [20]

    Noam Nisan and Amir Ronen. 1999. Algorithmic mechanism design. InProceed- ings of the thirty-first annual ACM symposium on Theory of computing. 129–140

    1999

  21. [21]

    2022.Introducing ChatGPT

    OpenAI. 2022.Introducing ChatGPT. https://openai.com/index/chatgpt/

    2022

  22. [22]

    2024.Introducing OpenAI o1

    OpenAI. 2024.Introducing OpenAI o1. https://openai.com/o1/

    2024

  23. [23]

    OpenAI. 2024. OpenAI o3-mini. https://openai.com/index/openai-o3-mini/

    2024

  24. [24]

    2025.OpenRouter - The Unified Interface For LLMs

    OpenRouter. 2025.OpenRouter - The Unified Interface For LLMs. https: //openrouter.ai/

    2025

  25. [25]

    Eden Saig, Ohad Einav, and Inbal Talgam-Cohen. 2024. Incentivizing Quality Text Generation via Statistical Contracts. InThe Thirty-eighth Annual Conference on Neural Information Processing Systems. https://openreview.net/forum?id= wZgw4CrxwK

    2024

  26. [26]

    Guoheng Sun, Ziyao Wang, Bowei Tian, Meng Liu, Zheyu Shen, Shwai He, Yexiao He, Wanghao Ye, Yiting Wang, and Ang Li. 2025. CoIn: Counting the Invisible Reasoning Tokens in Commercial Opaque LLM APIs. arXiv:2505.13778 [cs.AI] https://arxiv.org/abs/2505.13778

    Pith/arXiv arXiv 2025

  27. [27]

    Haoran Sun, Yurong Chen, Siwei Wang, Wei Chen, and Xiaotie Deng

  28. [28]

    Zico Kolter, and Zhuang Liu

    Mingjie Sun, Yida Yin, Zhiqiu Xu, J. Zico Kolter, and Zhuang Liu. 2025. Idiosyn- crasies in Large Language Models. arXiv:2502.12150 [cs.CL] https://arxiv.org/ abs/2502.12150

    Pith/arXiv arXiv 2025

  29. [29]

    arXiv:2405.16276 [cs.GT] https://arxiv.org/abs/2405.16276

    Mechanism Design for LLM Fine-tuning with Multiple Reward Models. arXiv:2405.16276 [cs.GT] https://arxiv.org/abs/2405.16276

    arXiv

  30. [30]

    2023.Announcing Together Inference Engine – the fastest inference available

    TogetherAI. 2023.Announcing Together Inference Engine – the fastest inference available. https://www.together.ai/blog/together-inference-engine-v1

    2023

  31. [31]

    Arun James Thirunavukarasu, Darren Shu Jeng Ting, Kabilan Elangovan, Laura Gutierrez, Ting Fang Tan, and Daniel Shu Wei Ting. 2023. Large language models in medicine.Nature medicine29, 8 (2023), 1930–1940

    2023

  32. [32]

    Ander Artola Velasco, Stratis Tsirtsis, Nastaran Okati, and Manuel Gomez- Rodriguez. 2025. Is Your LLM Overcharging You? Tokenization, Transparency, and Incentives. arXiv:2505.21627 [cs.GT] https://arxiv.org/abs/2505.21627

    Pith/arXiv arXiv 2025

  33. [33]

    Ander Artola Velasco, Stratis Tsirtsis, and Manuel Gomez-Rodriguez. 2025. Au- diting Pay-Per-Token in Large Language Models. arXiv:2510.05181 [cs.CR] https://arxiv.org/abs/2510.05181

    arXiv 2025

  34. [34]

    J Wang, H Liu, and M Zhang. 2025. Auditing LLMs with Adversarial Multi-Armed Bandits. InICLR

    2025

  35. [35]

    Heng Wang, Shangbin Feng, Tianxing He, Zhaoxuan Tan, Xiaochuang Han, and Yulia Tsvetkov. 2023. Can language models solve graph problems in natural language?Advances in Neural Information Processing Systems36 (2023), 30840– 30861

    2023

  36. [36]

    K Zhang, R Wang, and Z Liu. 2023. Contextual Bandit RLHF: Reducing Annotation Cost via Thompson Sampling. InNeurIPS

    2023

  37. [37]

    An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, Chujie Zheng, Dayiheng Liu, et al . 2025. Qwen3 Technical Report. arXiv:2505.09388 [cs.CL] https: //arxiv.org/abs/2505.09388

    Pith/arXiv arXiv 2025

  38. [39]

    Xuandong Zhao, Sam Gunn, Miranda Christ, Jaiden Fairoze, Andres Fabrega, Nicholas Carlini, Sanjam Garg, Sanghyun Hong, Milad Nasr, Florian Tramer, Somesh Jha, Lei Li, Yu-Xiang Wang, and Dawn Song. 2024. SoK: Watermarking for AI-Generated Content. arXiv:2411.18479 [cs.CR] https://arxiv.org/abs/2411.18479 A Proofs A.1 Impossibility of First-Best User Utilit...

    Pith/arXiv arXiv 2024

  39. [2024]

    InThe Twelfth International Conference on Learning Representations

    MetaGPT: Meta Programming for A Multi-Agent Collaborative Frame- work. InThe Twelfth International Conference on Learning Representations. https: //openreview.net/forum?id=VtmBAGCN7o