acceptodds
Under review as a conference paper at ICLR 2027

AuditGym: Can Black-Box Audits Verify the Model Behind an LLM API?

Abstract

Large language models (LLMs) are increasingly accessed through APIs and embedded in agent systems, yet users have limited evidence that the API actually serves the model it claims. Existing black-box behavioral audits approach this problem through equality testing, model identification, and fingerprinting. However, their outcomes are difficult to interpret and compare: a detected discrepancy may reflect either a different model or a change in how the same model is deployed. We introduce AuditGym, a benchmark for systematically evaluating LLM identity verification under controlled deployment changes. AuditGym separates model specification, including checkpoints, learned adapters, and quantization, from generation policy and the interaction layer, and tests whether auditors reject changes to the former while accepting changes to the latter. We evaluate four auditing approaches across seven change families and 19 checkpoints, including models running inside real agent harnesses. All evaluated methods achieve only limited reliability for the identity verification: all four detect checkpoint substitution but miss finer model changes such as adapters and quantization. More seriously, every method rejects unchanged models under certain generation, watermarking, system-prompt changes, or agent harnesses. With these results, we reveal that current auditors confuse model changes with deployment changes, and AuditGym provides a controlled foundation towards closing this gap. Our anonymous codebase is available at https://anonymous.4open.science/r/auditgym_iclr-BC1E/.

Primary area:
datasets and benchmarks
Keywords:
Model Equality Test, Model Provenance

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.20 over 5 reviews, above 49% of the others.
Reviewer_UUfyOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

he paper asks whether existing black-box behavioral audits can verify that an API serves the model it claims. It decomposes a deployment into a model specification MM (checkpoint, learned adapter, numerical representation), a generation policy GG (decoding, generation-time watermarking) and an interaction layer II (system prompt, agent harness), and defines the verification target as rejecting changes to MM while accepting changes to GG or II. AuditGym then builds reference-target pairs that differ in one known factor, hides the ground truth from the auditor, and runs four auditors — MET, RUT, AgentProv, and a verification adaptation of LLMmap — over 19 checkpoints and seven change families at a nominal α=0.05\alpha = 0.05.

The reported results are that all four auditors detect checkpoint substitution almost perfectly (181–182 of 182); that MET, RUT and AgentProv miss many adapter (6–7 of 10) and quantization (30, 51, 43 of 62) changes, with INT8 hardest (2/12, 4/12, 1/12 on the twelve shared BitsAndBytes models), while LLMmap detects all of both (10/10 and 62/62) at the cost of 3/14 false detections on the unchanged-deployment control; and that every method falsely rejects unchanged models under some decoding, watermarking, system-prompt or harness change (MET 36/80 and RUT 60/60 under decoding changes, LLMmap 45/45 under system prompts, and all four flagging all five unchanged models under the DeepSeek harness). The claimed contribution is the benchmark itself and the conclusion that current auditors confuse model changes with deployment changes.

I note the framing, because it is the paper's most durable contribution: a detected discrepancy does not establish a change of model, and a non-detection does not establish that the model is unchanged.

Critical strengths

1. The paper fixes a two-sided verification contract before measuring anything, and it is unusually careful that each intervention actually intervened. Prior auditing papers report detection without stating which differences ought to trigger rejection, so a rejection cannot be interpreted. Separating MM from GG and II, then reporting detection and false detection on the same controlled pairs, is the right primitive, and Section 3.3 draws the distinction honestly rather than scoring a point: when a decoding change moves the response distribution, MET or RUT rejecting H0:Pref=PtgtH_0: P_{\mathrm{ref}} = P_{\mathrm{tgt}} may be statistically correct and still wrong for verifying Mref=MtgtM_{\mathrm{ref}} = M_{\mathrm{tgt}}. Few papers that repurpose other people's methods concede this.

The same care shows in the details that are easy to skip. One Mistral medical adapter produces no parameter update and is excluded (Appendix B.2), leaving ten adapter comparisons — that is, the authors checked whether each intervention was real rather than banking a guaranteed miss. The quantization trend is not left resting on heterogeneous model coverage: on the twelve shared BitsAndBytes models the four-bit-over-INT8 ordering still holds (MET 2/12 INT8 vs 11/14 FP4 overall, 10/12 FP4 on the shared subset; RUT 4/12 vs 12/12; AgentProv 1/12 vs 10/12), which is a confound the authors controlled on their own initiative. And the arithmetic is internally exact everywhere I checked: Table 2 sums to Table 1's quantization row for all four methods (30, 51, 43, 62 of 62), Table 3's per-setting counts sum to its totals (36/80, 60/60, 19/80, 5/80), Table 4's watermark rows sum to 42, 17, 28 and 7 of 52, Table 5's δ=2\delta = 2 column reproduces Table 4's KGW row cell by cell, Table 6's two breakdowns of the same 45 comparisons agree (38, 39, 37, 45), and checkpoint substitution is 14×13=18214 \times 13 = 182. Benchmark papers are where arithmetic slips usually surface; here they do not.

2. The watermark asymmetry is a genuinely new empirical result, and it is the kind of result the framing exists to produce. MET flags all thirteen models under SynthID-Text, TextSeal and Gumbel-max but only three of thirteen under KGW, while RUT shows nearly the reverse pattern (Table 4). This is more than "deployment changes perturb auditors": it is evidence that different audit features track different behavioral channels, and it is the finding most likely to seed follow-up work. It also only becomes legible because the benchmark holds MM fixed and varies one factor, which is the design paying off. I state it as a strength with its limit attached — Appendix B.5 says watermark strengths are not matched across families, so the pattern is real but its mechanism is open.

Critical weaknesses

1. The harness conclusion that the abstract escalates to "more seriously" has no negative control, and the control that would settle it was collected and never reported. Appendix B.7 states: "Ten additional same-model comparisons within matched harnesses serve as diagnostics. The study does not include bare-versus-bare controls." So the measurement that would make the lower block of Table 7 interpretable exists, and its result appears nowhere — Table 21, which disaggregates that block, marks every same-model pair with a dash. Without the matched-harness same-model false-detection rate, 20/20 directed substitutions under Codex Default and 19–20/20 under DeepSeek is also exactly what a rule that always rejects would score. The upper block (bare reference vs same model under a harness, 5/5 and 4–5/5 false detections) is the headline claim, and it is being contrasted against a lower block whose own noise floor is unmeasured.

The same rows are independently confounded by generation that did not work. For RUT, Llama–DeepSeek has 6,375 empty outputs among 7,480 completed reference tasks and 64 among 74 target tasks, with empty outputs scored −1-1; Llama produces no valid native tool call under either harness; available tools "are not forced to execute"; for AgentProv, bare responses are labeled by a fixed LLM judge while harness responses are read off the first schema-conforming tool call, so action extraction differs between the two sides being compared; and MET and RUT "select completed responses under post-collection protocol amendments", which changes the estimand to P(Y∣task completed)P(Y \mid \text{task completed}) without reporting completion rates. A rejection computed between a mostly-empty response distribution and a non-empty one is not evidence that a harness invalidates a reference.

This is consequential rather than pedantic because the harness extension is the paper's most valuable direction — it is the condition a practitioner actually faces — and it is the part on which I can place the least weight. It is also the most cheaply fixed weakness in the paper: report the ten diagnostics, add bare-versus-bare controls, hold action extraction fixed across conditions, and report completion, empty-output and tool-execution rates alongside every harness count.

2. The counts that carry every comparative claim have an unmeasured noise floor, do not always describe a common target or a common budget, and cannot be recomputed by a reader, because the artifact contains no measurements. Four independent legs, each sourced from the paper or the supplement:

(a) The one measurement of the noise floor is large and was not propagated. Appendix B.6: MET's "earlier complete collection with the same rendered prompts but different request-seed streams gives 29/45 detections, compared with 38/45 in the primary collection. No individual outcomes are selected between the two collections." That is a same-condition re-run of a headline false-detection count moving by nine of forty-five, about twenty percentage points. I take the authors at their word that no cherry-picking occurred, and I credit them for disclosing it; the problem is what it implies for the rest of the paper. No other cell is repeated, so no count anywhere in Tables 1–7 has a stated noise floor, and the paper's conclusions are drawn from differences between single-run counts that this one re-run suggests can move by that much.

(b) Cross-method comparisons do not always compare the same target. Appendix B.3: "These conversion and precision differences mean that quantized targets are not identical across all auditors." Within a method a pair remains interpretable, but a statement such as "RUT detects quantization better than MET" is then confounded with which quantized artifact each auditor was served. Matching conditions inside each pair does not fix comparisons across methods.

(c) Evidence budgets differ by orders of magnitude, and the decoding totals are not computed over a common set of settings. Per comparison, RUT uses 100 probes with 100 reference responses and one target response each — 10,000 reference and 100 target responses — while LLMmap uses three enrollment traces plus 199 calibration traces at eight probes each, 1,616 reference responses, against a single eight-probe target trace. Keeping each method's native protocol is defensible, but then the table answers "how does each full pipeline do at its own cost", not "which method is better". More specifically, Table 3's Total row compares RUT over six settings against the other three over eight, and the two extra settings are the top-k ones RUT excluded because, per Appendix C.2, "Top-k = 1 does not make the responses deterministic, so we cannot confirm that top-k is applied" — a serving-path problem that would apply to every auditor, not a property of RUT. Restricted to the six settings all four share, the totals are MET 34/60, AgentProv 19/60 and LLMmap 4/60 against RUT's 60/60. The ranking survives; the printed Total column is not a like-for-like comparison and the paper does not say so.

(d) No reported number can be checked offline. I ran the supplement: pip install -e ".[test]" succeeds, the CPU mock quickstart completes, and pytest gives 988 passed, 1 skipped. The engineering is real — 381 files, content hashes on every artifact, reference and target contract hashes compared bidirectionally, independent_sampling_streams asserted, and load_protocol checking the eleven ordered pairs against α=0.05\alpha = 0.05, seed 42 and repetition 0. But the README states that collected responses, results and logs are excluded, and that is accurate: there are no response banks, no intermediate statistics, and not even per-comparison statistic and pp-value tables. The files named *_results.py are scoring drivers that read response banks and cannot run without them. For a submission whose contribution is a benchmark, the measurements are the artifact; as released, a reader can inspect the harness and must take all 19 models' numbers on trust. Three of the five submissions I am reviewing this cycle do ship their recorded results, so this is a solvable problem rather than a norm of the area.

These legs compound with a fifth issue specific to the method that looks best. LLMmap's nominal level is not established in the regimes where it posts its lowest false-detection counts. Appendix B.7 reports that some greedy reference conditions contain only one to four distinct calibration traces and that "reference and target collection layouts differ in some conditions, limiting the exchangeability assumption underlying nominal calibration". The supplement pins the mechanism down: paper_settings/llmmap-decoding-v3-protocol.json freezes α=0.05\alpha = 0.05 with 199 calibration samples and one target trace, and records the rule as calibration 199, rank 190, reject on target_distance > threshold, ties not rejected; equality/methods/llmmap.py computes that rank as ⌈(n+1)(1−α)⌉=190\lceil (n+1)(1-\alpha) \rceil = 190 and takes sorted(distances)[189]. Because the protocol carries an explicit α\alpha, this is the path Table 3 runs, not the empirical_quantile branch. The consequence is arithmetic: the threshold equals the largest calibration distance exactly when that largest value occurs at least n−rank+1=10n - \mathrm{rank} + 1 = 10 times, and any target sitting on an already-seen distance is then accepted by construction. That is a condition on the multiplicity of the maximum, not on the number of distinct values, and per-condition calibration frequencies are not released — so I do not claim LLMmap's 0/10 cells are caused by a saturated threshold. I claim the nominal level is not established there, and that the paper's cross-method counts assume it holds. I also want to be fair about magnitudes in the other direction: LLMmap's 5/80 is 6.25% at a nominal 5% level and should not be read as a failure comparable to RUT's 60/60; with shared references inducing dependence, an independent binomial test is not available either way.

Questions for authors

Items 1 and 2 are correction requests rather than questions; the rest are the answers most likely to move my assessment.

  1. Please correct the abstract. It states that "all four detect checkpoint substitution but miss finer model changes such as adapters and quantization", which Table 1 contradicts: LLMmap is 10/10 on adapters and 62/62 on quantization. The accurate version — MET, RUT and AgentProv miss many adapter and quantization changes, while LLMmap detects all of them in these settings but produces 3/14 false detections on the unchanged-deployment control and up to 45/45 under system prompts — is no weaker as a result, and it is the sentence most readers will carry away.

  2. Please report the ten matched-harness same-model diagnostics named in Appendix B.7, and state the bare-versus-bare false-detection rate or that it is unmeasured. Without them, the 19–20/20 substitution figures cannot be distinguished from what an always-reject rule achieves. If those diagnostics show a non-trivial false-detection rate under matched harnesses, which of Section 4.4's conclusions change?

  3. How many of the paper's counts move under re-collection? Appendix B.6's 29/45 versus 38/45 is the only same-condition repeat reported. For a representative subset of cells across the seven change families, what are the counts under at least two independent collections, and does any conclusion in Sections 4.2–4.4 depend on a difference smaller than that spread?

  4. For the harness rows of Table 7, what do the results look like restricted to models and conditions producing non-empty, parseable responses on both sides, with action extraction held fixed between bare and harness conditions? Specifically, does "unchanged model, bare reference" remain 5/5 for RUT once the Llama–DeepSeek condition with 6,375/7,480 empty reference outputs is excluded? Please also report completion, empty-output and tool-execution rates next to each count.

  5. For the LLMmap decoding and watermark cells, how often does the 190th of the 199 ordered calibration distances equal the largest, equivalently how often does the largest distance occur at least ten times? That multiplicity, not the count of distinct values, decides whether the threshold is saturated, and it is what Appendix B.7's "one to four distinct calibration traces" leaves open. What are the false-detection counts restricted to cells where it does not hold? Reporting the distance and threshold distributions, plus same-deployment controls across collection batches, restarts and batching layouts, would settle this directly. I would also suggest naming the method "LLMmap (verification adaptation)" throughout, so that conclusions here are not read back onto the original identification method.

  6. Can the quantization comparison be re-run with a target artifact common to all four auditors, and can one cost-matched variant be reported alongside the native protocols — matched target tokens or matched target responses, with reference-preparation, target-audit and auxiliary scoring or judging costs reported separately? This is what would restore the cross-method column as a comparison.

  7. Does the benchmark admit an "insufficient evidence" verdict? For a binary verifier, Pr⁡Q0(reject)+Pr⁡Q1(accept)≥1−TV(Q0,Q1)\Pr_{Q_0}(\text{reject}) + \Pr_{Q_1}(\text{accept}) \ge 1 - \mathrm{TV}(Q_0, Q_1), where Q0Q_0 and Q1Q_1 are the audit-record distributions under a permitted redeployment and under a changed model, so when the two are close at the given query budget, low false rejection and low miss cannot be achieved together. Stating the permitted change set, the detectable change scale and the query budget, and allowing abstention, would let the paper separate three failure sources it currently pools: an improvable method, an insufficient budget, and a genuine identifiability limit. Relatedly, would you consider stating explicitly that AuditGym instantiates one strict contract in which numerical representation is part of identity, rather than the only reasonable notion?

  8. Two reporting items. Appendix C.2 explains RUT's top-k "N/A" as an inability to confirm that top-k reached the sampler; since that is a serving-path property rather than a method limitation, should the other three methods' top-k columns be marked the same way, and the Total row computed over the six verified settings? And the Qwen3.5-4B AWQ target that "returns empty one-token stops on the audit" is currently counted as a successful quantization detection — could endpoint failures be reported separately from detections of a served quantized model, so that model-identity detection is not pooled with liveness detection?

  9. The AgentProv action labels "have not been independently validated by humans". For the adapter, quantization and system-prompt studies, could you report a stratified human spot-check with agreement rates and typical error modes? This matters most for the system-prompt study, where an instruction can change surface form in ways that alter how the judge extracts an action without the underlying tool preference changing.

  10. Would you release the collected response banks, or failing that the per-comparison statistics and pp-values? The protocol freezing and content-hashing machinery already in the code suggests this is a packaging decision rather than new work, and it is what would make the benchmark's central claims independently checkable.

3 comments

We thank the reviewer for recognizing our explicit verification contract, the care of our controlled experimental design, and the distinction between detecting distributional differences and verifying model identity. We also appreciate their recognition of the watermark asymmetry as a new empirical finding with value for follow-up work. Below, we address the reviewer’s comments individually.

W1.1 / Q2: Matched-harness controls and the always-reject baseline

Thank you for suggesting these controls. We now report bare-versus-bare controls and all ten matched-harness same-model comparisons for each of the four original auditors in Table 8.

Unchanged-deployment controlMETRUTAgentProvLLMmap (verification adaptation)
Bare vs. bare0/50/50/52/5
Codex Default vs. Codex Default1/50/50/50/5
DeepSeek Minimal vs. DeepSeek Minimal0/50/50/50/5

Across the ten matched-harness controls, MET produces one false detection, while the other three auditors produce none. Together with the 19–20/20 substitution detections in Table 7, these results rule out an always-reject explanation. The qualitative conclusion is unchanged: high substitution detection within a matched harness coexists with frequent rejections of unchanged models against harness-free references.

W1.2 / Q4: RUT results after excluding empty responses

We recalculated the RUT tests after excluding empty responses from both reference and target samples, with calibration based on the retained sample counts. Across all five models, including Llama, this yields 5/5 bare-to-DeepSeek rejections and 0/5 matched DeepSeek control rejections. The revised results are reported in Tables 7 and 8.​

W1.3 / Q4: Consistent AgentProv action extraction across conditions

Thank you for this helpful suggestion. Following your recommendation, we aligned AgentProv’s action extraction across bare and harness conditions. The bare reference now receives tools through the native API, and both sides use the first delivered tool-call name without an LLM judge. We recalculated the comparisons and report the revised results below.

AgentProv comparisonFalse detections / comparisons
Bare vs. bare0/5
Bare vs. DeepSeek Minimal2/5
Bare vs. Codex Default3/5

With the same extraction rule, unchanged models still trigger rejections under both harnesses, while independently collected bare-versus-bare controls yield none. Table 7 reports the revised results, and Table 23 provides per-model decisions.

W1.4: Agent-harness controls and component breakdown

We thank the reviewer for recognizing the practical importance of the harness extension. We added a controlled Mini SWE study across five unchanged models and four auditors, varying the instruction package, Bash tool interface, and execution feedback while keeping each auditor’s observation rule consistent across conditions.

ReferenceTargetMETRUTAgentProvLLMmap
BaseBase + instructions5/55/54/55/5
BaseBase + tools5/55/50/55/5
Base + instructionsBase + instructions + tools5/55/53/55/5
Base + toolsBase + instructions + tools5/55/55/55/5
Instructions + tools, fixed feedbackInstructions + tools, real feedback1/50/5N/A2/5
BaseFull Mini SWE with real feedback4/55/54/55/5

Entries are false detections across five unchanged models. Tools return fixed acknowledgements unless real feedback is specified. AgentProv retains its probe tools throughout, its feedback comparison is N/A because feedback follows its observed first tool choice. LLMmap denotes the verification adaptation. ​

Instructions and tool interfaces produce more consistent rejections than execution feedback in this study. AgentProv also shows that tool-interface sensitivity depends on the surrounding instructions. These results extend the whole-harness evaluation by showing which component changes affect reference compatibility in Mini SWE. Table 9 reports the results, and Appendix B.8 provides the setup details.

W2(a) / Q3: Re-collection variability and stability of conclusions

Our investigation traced 8 of the 9 additional detections to MET’s Phi results. We conducted additional data collections and targeted Phi checks for the other auditors, observing no changes in the detection counts for RUT and LLMmap, and only a single change for AgentProv. Across these additional collections, system-prompt changes continued to trigger false detections, reinforcing the paper’s central finding. For the camera-ready version, we will extend this analysis with a multi-seed variation study across auditors, models, and change families.

W2(b) / Q6: Shared quantized targets and cross-method comparability

The targets are separately generated quantized versions of the same pinned base checkpoints. MET and RUT used different calibration settings and quantization-software versions, producing valid four-bit AWQ/GPTQ targets. We have specified these settings in Appendix B.3. Each audit compares a quantized target with its corresponding unquantized reference. The finding that MET, RUT, and AgentProv can miss quantization changes therefore remains supported.

W2(c) / Q6 / Q8.1: Evidence budgets and consistent top-k reporting

We retain each auditor’s original protocol and evidence budget to evaluate the method as designed; these budgets are specified in Appendix C. Following your suggestion, we removed both top-k settings for all methods. The four original auditors now cover the same six decoding settings and ten models, as reported in Table 3 and Appendix Table 20. The finding that decoding changes trigger false detections remains supported.

W2(d) / Q10: Release of per-comparison results and reproducibility artifacts

Thank you for suggesting this addition. We have added per-comparison statistics, p-values or decision thresholds, audit decisions, configurations, and offline table-generation scripts to our anonymous repository. The package allows readers to reproduce the reported table counts without running model inference.

W2(e) / Q5: LLMmap calibration saturation, controls, and naming

We examined all 23 reference banks used for decoding and watermarking. Each contains 199 distinct calibration distances, so the maximum occurs only once and the rank-190 threshold is always below it. No cases are excluded by the proposed saturation check; the reported counts remain 4/60 for decoding and 7/52 for watermarking. Unchanged-deployment controls yield 1/10 and 0/13, respectively. Decoding uses the same persistent server per model, and watermark collection uses matched software and worker configurations. The low-diversity observation concerns the separate greedy harness study. Appendix C.4 confirms that the calibration thresholds are below the maximum distance. We adopt the name LLMmap (verification adaptation) as suggested.

Q1: Accurate method-specific claims in the abstract

We have revised the abstract to distinguish the methods: MET, RUT, and AgentProv miss some adapter and quantization changes, whereas LLMmap (verification adaptation) detects all tested changes in these settings but falsely rejects 3/14 unchanged deployments, consistent with Table 1.

Q7: Insufficient evidence, identifiability, and the verification contract

AuditGym supports application-specific verification contracts. Our evaluation treats numerical representation as part of model identity, while applications may permit quantization. Table 2 characterizes each auditor’s quantization sensitivity and can guide method selection under either contract. We now make this explicit in Problem Formulation. We retain each auditor’s native decision rule and evidence budget, without adding a calibrated “insufficient evidence” verdict. Such an outcome is a useful extension: non-rejection alone cannot distinguish limited method sensitivity, insufficient evidence, and an identifiability limit. We clarify in Auditing Procedures and Assessment that our results measure sensitivity at the stated budgets, and that non-rejection neither certifies identity nor establishes undetectability.

Q8.2: Separating AWQ endpoint failures from model-change detection

We checked this case, identified a Qwen3.5-specific AWQ conversion defect, and corrected it. The repaired deployment passes usability validation, and all eight recollected audit responses are nonempty. With the original reference, calibration, and decision rule, LLMmap still detects the quantization change. Tables 1 and 2 therefore retain 62/62 overall and 11/11 AWQ detections, with this case now evaluated on responses from the functioning quantized model.

Q9: Human validation of AgentProv action labels

Our evaluation asks whether AgentProv’s complete auditing pipeline distinguishes model changes from permitted deployment changes. Its action-extraction judge is part of that pipeline and is applied consistently across reference and target conditions. Appendix C.3 specifies the action-extraction judge and procedure.

Additional analysis: Watermark sensitivity and utility

We thank the reviewer for highlighting the watermark asymmetry as a promising direction for follow-up work. We investigated whether audit rejection is associated with utility degradation caused by watermarking, evaluating GSM8K accuracy, MBPP pass@1, and generated-text perplexity across thirteen models. MET rejects all thirteen models under selected SynthID-Text and TextSeal settings, despite small average changes in accuracy on both tasks. Thus, watermarking can trigger audit rejection without substantially degrading average task performance. We report this additional study in Appendix D.


If the above answers address the Reviewer's concerns, we would greatly appreciate it if they could consider increasing the rating. We are also happy to address any remaining questions.

Reviewer_vPzsOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces AuditGym which is a benchmark for evaluating whether black-box auditing methods can verify the identity of an LLM served through an API. The authors distinguish between changes to the underlying model specification (checkpoint substitution, LoRA adapters, and quantization) and changes to deployment settings (decoding policies, watermarking, system prompts, and agent harnesses). Under their definition, a reliable auditor should detect model specification changes while remaining robust to deployment changes.

The authors evaluate four existing auditing methods (MET, RUT, AgentProv, and LLMmap) across seven types of changes and 19 model checkpoints. The experiments show that all four methods can reliably detect checkpoint substitutions, but some struggle with LoRA and quantization changes. Meanwhile, changes in decoding settings, watermarking, system prompts, and agent harnesses can cause false detections even when the underlying model is unchanged. The paper concludes that existing auditing methods are not yet reliable for model identity verification and provides a controlled benchmark for evaluating future methods.

Critical strengths

I think verifying whether an LLM API actually serves the model it claims is an interesting and important problem, both commercially and from the perspective of transparency and trustworthiness as more users and applications rely on third-party LLM APIs.

I appreciate the separation of model specification (M), generation policy (G), and interaction layer (I). This provides a clear framework for distinguishing changes to the underlying model from changes in how the model is deployed. I also think the controlled evaluation is well designed overall, since it allows the authors to test different types of changes with known ground truth and systematically compare existing auditing methods. The evaluation across multiple models and auditing approaches provides useful empirical evidence about their limitations.

Critical weaknesses
  1. The practical significance of the model identity definition is not sufficiently justified.

I understand that the authors distinguish model changes (checkpoint substitution, LoRA, and quantization) from deployment changes (decoding settings, system prompts, and agent harnesses). However, I am not fully convinced why these are the particular changes we should or should not care about. For example, why should we necessarily detect every LoRA or quantization change? Such changes may have little impact on actual model performance. On the other hand, changes that do not modify the model parameters, such as reducing reasoning effort from high to low or modifying system prompts, may significantly affect the quality of the service.

From a consumer's perspective, whether the API actually delivers the advertised model, as well as its performance, reasoning capability, latency, and cost, may be more important than whether the underlying numerical representation has changed. I think the paper should better justify why its definition of model identity is meaningful for real-world API auditing. Without this justification, it is difficult to assess the practical significance of the proposed benchmark.

  1. The novelty and new scientific insights beyond existing work are not clear to me.

I understand that the paper provides a controlled benchmark and systematically evaluates four existing auditing methods. However, several of the model modifications, deployment changes, and failure modes have already been studied in prior work, including LeaFBench, AgentProv, and KBF. I am not entirely clear about what fundamentally new insights we gain from this benchmark beyond bringing existing methods and experiments into a common evaluation framework.

For example, it seems somewhat expected that distribution-based auditing methods would detect differences when temperature or system prompts change, since these settings can alter the output distribution. I would like to understand what new scientific conclusions the benchmark enables, why the observed failures occur, and how these findings could guide the development of better auditing methods. The limited discussion of these aspects makes it difficult for me to assess the paper's novelty and overall contribution.

Questions for authors

Could the authors clarify why changes such as LoRA and quantization should always be detected, while changes to system prompts or generation settings should not? I understand the distinction based on model specifications, but I am not fully convinced how this corresponds to real-world API auditing needs. For example, users may care more about changes in reasoning effort, model performance, or service quality than whether the model is quantized. What real-world model or service guarantees motivate this particular definition?

Could the authors clarify what new scientific insights AuditGym provides beyond existing evaluations such as LeaFBench, AgentProv, and KBF? I understand the contribution of a unified controlled benchmark, but several of the changes and failure modes have been studied before. Which findings are genuinely new or unexpected, and what do they teach us about designing more reliable auditing methods?

Table 6 reports a high false-positive rate for AgentProv (37/45), which appears substantially higher than the results reported in the original AgentProv paper. Could the authors explain this discrepancy? Understanding the source of this difference would help assess how generalizable the reported failure is.

3 comments

We thank the reviewer for recognizing the practical importance of verifying model identity for API transparency and trust, the clarity of our model–generation–interaction framework, and the value of our controlled evaluation across models and auditing methods. Below, we address the reviewer’s comments individually.

W1/Q1. Could the authors clarify why changes such as LoRA and quantization should always be detected, while changes to system prompts or generation settings should not? I understand the distinction based on model specifications, but I am not fully convinced how this corresponds to real-world API auditing needs. For example, users may care more about changes in reasoning effort, model performance, or service quality than whether the model is quantized. What real-world model or service guarantees motivate this particular definition?

AuditGym provides a framework for evaluating auditing methods under user-specific verification contracts. Users specify which deployment changes their application permits. Our study measures whether different auditors detect changes to the model, generation policy, and interaction layer, providing evidence for selecting methods under those contracts.

Our evaluation adopts one explicit contract that includes the checkpoint, learned adapters, and numerical representation. The framework also supports alternative contracts. For example, the quantization results in Table 2 characterize useful sensitivity when exact precision is promised and unwanted rejection when quantization is permitted. The same measurements therefore inform method selection under either guarantee. LoRA results similarly characterize whether auditors detect adapter changes, without prescribing whether an application should permit them.

We agree that performance, reasoning capability, latency, and cost can matter to users alongside model identity. AuditGym does not rank these priorities or equate a model change with degraded service quality. It provides a controlled testbed for assessing auditing behavior against the user's chosen guarantee. Section 3.1 now makes the contract flexibility and its role in guiding auditor selection explicit. AuditGym also supports studying audit decisions alongside task performance. Appendix D relates audit rejection to GSM8K accuracy, MBPP pass@1, and generated-text perplexity under watermarking. High rejection can coexist with small average task-performance changes, illustrating how the framework distinguishes auditing sensitivity from effects on utility.

W2/Q2. Could the authors clarify what new scientific insights AuditGym provides beyond existing evaluations such as LeaFBench, AgentProv, and KBF? Which findings are genuinely new or unexpected, and what do they teach us about designing more reliable auditing methods?

We compare AuditGym with prior evaluations in the table below and include this comparison as Table 10 in Appendix A of the revised paper.

✅ indicates inclusion. ❌ indicates that the setting was not included in the cited evaluation.

Evaluation settingLeaFBenchMETAgentProvKBFAuditGym
Configurable verification contracts❌❌❌❌✅
M Checkpoint substitution✅✅✅✅✅
M LoRA / PEFT✅❌✅❌✅
M Quantization✅✅✅✅✅
G Decoding settings✅✅❌✅✅
G Output watermarking❌✅❌❌✅
I System prompts✅❌✅✅✅
I RAG✅❌❌✅❌
I Agent harness❌❌✅✅✅

The table summarizes broad evaluation settings. AuditGym also provides more detailed coverage within these settings. MET evaluates KGW, while AuditGym evaluates four watermark families and varies KGW strength. AgentProv studies agent-wrapper prompts, and KBF compares agent CLIs with API references. AuditGym additionally pairs reference-transfer tests with model substitutions inside a fixed harness and examines the effects of instructions, tools, and execution feedback separately.

We have clarified the following four contributions in the revised introduction.

1. An explicit model-verification framework. We separate model specification (M), generation policy (G), and interaction layer (I), making sensitivity to model changes and robustness to permitted deployment changes jointly assessable. The framework supports user-specific verification contracts. This differs from LeaFBench's source-model attribution objective, under which a quantized or fine-tuned derivative can retain its source label despite changing the advertised model specification (Section 2 and Section 3.1).

2. A benchmark with controlled deployment ground truth. AuditGym pairs deployments with known differences across seven change families and 19 checkpoints. The revised evaluation covers seven auditing approaches while preserving their access requirements. We release the code and collected responses so that methods can be compared against known model and deployment changes within a common testbed.

3. New findings about the gap between auditing behavior and model verification. We show that existing auditors do not consistently satisfy the evaluated verification contract. Across seven methods, our experiments reveal missed model changes and false rejections under permitted deployment changes, including agent harnesses, demonstrating why checkpoint discrimination alone is insufficient for reliable model verification. For example, B3IT detects every tested checkpoint substitution but only two of twelve INT8 changes (Tables 1 and 2). Decoding, watermarking, and system prompts can cause auditors to reject unchanged models (Tables 3, 4, and 6). Successful substitution detection within a fixed harness can coexist with rejection of the unchanged model against a bare-model reference (Table 7).

The watermark results reveal contrasting sensitivities across auditors. MET rejects all tested models under SynthID-Text, TextSeal, and Gumbel-max but only 3/13 under KGW. RUT instead rejects all 13 KGW comparisons but only 4/39 across the other families (Table 4). Robustness to one watermark family therefore does not predict robustness to another, motivating evaluation across mechanisms rather than a single watermark.

The completed Mini SWE breakdown goes further by examining which components affect each auditor. Adding tools alone triggers 5/5 rejections for MET, RUT, and LLMmap but 0/5 for AgentProv. Adding the same tools with instructions already present triggers 3/5 AgentProv rejections. Exposing real execution feedback produces fewer rejections in this study, with 1/5 for MET, 0/5 for RUT, and 2/5 for LLMmap. Table 9 reports these comparisons, and Appendix B.8 describes the setup. These contrasts show that tool-interface sensitivity depends on the auditor and surrounding instructions. They motivate testing reference compatibility across component combinations, beyond checking that an auditor detects model substitutions.

4. A community testbed for developing more reliable auditors. AuditGym provides a controlled setting for evaluating new auditing methods, including models deployed inside real agent harnesses. Its joint sensitivity and robustness measurements guide method selection for a user's verification contract and identify properties that future methods should improve. Section 4.4 explains these implications for auditor design.

Q3. Table 6 reports a high false-positive rate for AgentProv (37/45), which appears substantially higher than the results reported in the original AgentProv paper. Could the authors explain this discrepancy? Understanding the source of this difference would help assess how generalizable the reported failure is.

AgentProv is robust to the tested generic helpful-assistant prompt, but often falsely flags unchanged models under more specific instructions, especially output constraints. The generic prompt causes 0/3 false detections, consistent with the original finding. Our broader set of fifteen instructions yields 37/45 false detections, including 17/18 under output constraints. Table 6 and Appendix E.3 report these results.


If the above answers address the Reviewer's concerns, we would greatly appreciate it if they could consider increasing the rating. We are also happy to address any remaining questions.

Reviewer_XdnFOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces AuditGym, a benchmark for black-box LLM identity verification that distinguishes model changes from deployment variations. Evaluating four auditing methods across seven intervention families and 19 checkpoints, the authors find that existing methods reliably detect checkpoint substitutions but often miss subtler changes such as LoRA and quantization. Meanwhile, decoding settings, watermarking, system prompts, and agent harnesses can cause auditors to falsely reject unchanged models.

Critical strengths
  1. Well-motivated problem formulation. The distinction between model identity and behavioral equivalence is important for understanding the limitations of existing black-box auditing methods. The proposed M/G/I decomposition provides a useful framework for organizing deployment changes.
  2. Broad empirical coverage. The benchmark examines several types of model modifications and deployment variations across multiple model families. The inclusion of agent harnesses is particularly relevant as LLMs are increasingly deployed within agentic systems.
  3. Useful empirical observations. The results highlight that strong checkpoint-substitution detection does not necessarily imply robustness to deployment changes or sensitivity to smaller parameter modifications.
Critical weaknesses
  1. Insufficient justification of the verification objective.Model identity may be unidentifiable under unknown deployment configurations. Moreover, MET and RUT were designed for distributional testing, so their reported failures partly reflect a mismatch in evaluation objectives.
  2. Confounded agent harness experiments. Differences in action extraction, response filtering, and limited actual tool execution make it difficult to attribute the high false-positive rates solely to harness changes.
  3. Limited experimental comparability. Quantization implementations and precision settings differ across auditors. The small LoRA evaluation and degenerate output cases further weaken the comparative conclusions.
  4. Insufficient novelty over prior work. Existing benchmarks such as LeaFBench already examine model modifications and deployment variations. The paper does not clearly establish its distinct contribution or evaluate closely related methods such as KBF.
Questions for authors
  1. Under what assumptions is model identity theoretically identifiable through black-box observations when generation policies and interaction layers are unknown? Does the proposed objective require restrictions on allowable deployment transformations?

  2. Can the authors provide additional harness experiments that use consistent observation and action-extraction mechanisms across reference and target conditions? In particular, can they isolate the effects of system prompts, tool catalogs, and actual tool execution?

  3. How sensitive are the reported method rankings to differences in quantization implementations and precision settings? Would the conclusions remain consistent if all auditors evaluated identical quantized checkpoints and degenerate output cases were excluded?

  4. What are the main conceptual and empirical differences between AuditGym and LeaFBench? Could the authors clarify why closely related black-box auditing methods such as KBF were not included?

2 comments

We thank the reviewer for recognizing our well-motivated problem formulation, the usefulness of the M/G/I decomposition, and the breadth of our empirical evaluation, particularly the inclusion of agent harnesses. We also appreciate their recognition of our finding that strong checkpoint discrimination does not necessarily imply robustness to deployment changes or sensitivity to smaller model modifications. Below, we address the reviewer’s comments individually.

W1/Q1. Under what assumptions is model identity theoretically identifiable through black-box observations when generation policies and interaction layers are unknown? Does the proposed objective require restrictions on allowable deployment transformations?

AuditGym supports application-specific verification contracts, users specify which model properties are guaranteed and which deployment changes are permitted. Our evaluation adopts an explicit contract covering the checkpoint, learned adapters, and numerical representation, while requiring robustness to generation-policy and interaction-layer changes. The same measurements also inform alternative contracts. For example, quantization sensitivity is desirable when exact precision is promised and undesirable when quantization is permitted. Section 3.1 makes this flexibility and its role in auditor selection explicit.

Identifiability requires restrictions on allowable deployment transformations: different model hypotheses must remain distinguishable through the available observations. If permitted transformations make them observationally identical, black-box identification is impossible; reliable verification at a finite query budget additionally requires sufficient separation. AuditGym uses controlled deployment ground truth to assess auditors’ sensitivity and robustness under concrete changes and stated budgets.

For MET and RUT, we retain their native decision rules and evidence budgets. Their rejection of a distributional change can be statistically correct even when the advertised model remains unchanged. Section 3.3 explicitly distinguishes these objectives: our results assess how their signals serve the chosen verification contract, rather than challenge the validity of their distributional tests.

W2/Q2. Can the authors provide additional harness experiments that use consistent observation and action-extraction mechanisms across reference and target conditions? In particular, can they isolate the effects of system prompts, tool catalogs, and actual tool execution?

Following your suggestion, we added a controlled mini-swe-agent component study. Codex and DeepSeek combine instructions, tool interfaces, and execution logic; Mini SWE provides a simpler framework for examining these components separately. We keep the model and each auditor’s observation and action-extraction rules consistent across conditions.

Table 9 reports the results across five unchanged models:

ReferenceTargetMETRUTAgentProvLLMmap
BaseBase + instructions5/55/54/55/5
BaseBase + tools5/55/50/55/5
Base + instructionsBase + instructions + tools5/55/53/55/5
Base + toolsBase + instructions + tools5/55/55/55/5
Instructions + tools, fixed feedbackInstructions + tools, real feedback1/50/5N/A2/5
BaseFull Mini SWE with real feedback4/55/54/55/5

Entries are false detections across five models. Base denotes the model without Mini SWE instructions or tools; AgentProv retains its probe tools throughout. Tools execute when called, with fixed acknowledgements replaced by actual command outputs in the feedback comparison. AgentProv observes the first tool choice, so subsequent feedback is inapplicable.

The breakdown shows that instructions and tool interfaces affect audit decisions more consistently than execution feedback in this study. Tool sensitivity also depends on the auditor and surrounding instructions: adding tools alone causes no AgentProv rejections, whereas adding them alongside instructions causes three. These component comparisons explain effects that the whole-harness results alone cannot distinguish.

Section 4.4 discusses these findings, and Appendix B.8 specifies the configurations and observation rules.

W3/Q3. How sensitive are the reported method rankings to differences in quantization implementations and precision settings? Would the conclusions remain consistent if all auditors evaluated identical quantized checkpoints and degenerate output cases were excluded?

Thank you for suggesting this clarification. The targets are separately generated quantized versions of the same pinned base checkpoints. MET and RUT used different calibration settings and quantization-software versions, producing valid four-bit AWQ/GPTQ targets. We have specified these settings in Appendix B.3.

Each audit compares a quantized target with its corresponding unquantized reference. The finding that MET, RUT, and AgentProv can miss quantization changes therefore remains supported.

For LoRA, the four original auditors evaluate the same ten effective adapter changes across five base models, covering instruction following, persona adaptation, coding, finance, translation, mathematics, and tool selection. This shared set tests sensitivity to practical fine-tuning changes. Appendix B.2 describes the coverage and protocol.

W4/Q4. What are the main conceptual and empirical differences between AuditGym and LeaFBench? Could the authors clarify why closely related black-box auditing methods such as KBF were not included?

AuditGym contributes an explicit model-verification framework that separates model specification, generation policy, and interaction layer, making sensitivity to model changes and robustness to permitted deployment changes jointly assessable. The framework supports user-specific verification contracts. This differs from LeaFBench’s source-model attribution objective, under which a quantized or fine-tuned derivative can retain its source label despite changing the advertised model specification (Section 2 and Section 3.1).

Table 10 in Appendix A compares the evaluation coverage.

✅ indicates inclusion. ❌ indicates that the setting was not included in the cited evaluation.

Evaluation settingLeaFBenchMETAgentProvKBFAuditGym
Configurable verification contracts❌❌❌❌✅
M Checkpoint substitution✅✅✅✅✅
M LoRA / PEFT✅❌✅❌✅
M Quantization✅✅✅✅✅
G Decoding settings✅✅❌✅✅
G Output watermarking❌✅❌❌✅
I System prompts✅❌✅✅✅
I RAG✅❌❌✅❌
I Agent harness❌❌✅✅✅

AuditGym additionally evaluates four output-watermark families and watermark strength, pairs reference-transfer tests with model substitutions inside fixed harnesses, and examines instructions, tools, and execution feedback separately. These experiments reveal why strong checkpoint discrimination alone does not establish reliable model verification and provide guidance for selecting and developing auditors (Section 4.4).

Following your suggestion, we have added KBF to the revised evaluation. Its results appear in Tables 1–7 and the per-comparison appendix. Results from Tables 1–7 are summarized below. ↑ indicates desired detections of model changes; ↓ indicates false detections on unchanged models. Counts include comparisons with a valid decision.

ComparisonKBF detections / valid decisions
Checkpoint substitution ↑106/166
Trained LoRA ↑1/10
Quantization ↑17/57
Unchanged deployment ↓0/13
Decoding changes ↓1/60
Output watermarking (four families) ↓2/52
System prompts ↓1/40
DeepSeek: unchanged model, bare reference ↓1/4
Codex: unchanged model, bare reference ↓2/5
DeepSeek: model substitution, matched harness ↑6/15
Codex: model substitution, matched harness ↑12/20

We also added B3IT and a FLIPS-based verification adaptation, expanding the evaluation from four to seven auditing methods. These additions further demonstrate AuditGym’s role as a common testbed for assessing complementary auditing approaches.


If the above answers address the Reviewer's concerns, we would greatly appreciate it if they could consider increasing the rating. We are also happy to address any remaining questions.

Reviewer_Jad6OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper introduced AuditGym. It is a testbed for blackbox llm identity verification. It decides from an API's outputs and a trusted reference, if the provider serve the claimed models. A deployment is split into: 1. model specification M, generation policy G, and interaction layer I. The paper uses four existing auditors to run with their native probes and budgets across 7 change families. all 4 auditors detect checkpoint substituion almost perfectly. The authors conclude that current auditors confuse model changes with deployment changes.

Critical strengths

This study establishes clear criteria for its assessments and conducts them with great rigor. For example, it it discloses variations among different auditing tools. It also verifies that the RUT method is unsuitable for top-k scenarios. The paper is clear and easy-to-follow.

Critical weaknesses
  1. The verification target is not shown to be achievable, so low "robustness" is hard to interpret.

The paper asks auditors to tolerate G and I changes drawn from an essentially unbounded class while still detecting INT8 quantization. One issue lies in "identifiability." Suppose a change—such as a modification to a hidden system prompt or a shift in the decoding method—alters the output distribution more significantly than the changes introduced by INT8 quantization or LoRA fine-tuning; in such a case, no functional transformation applied to the black-box output could satisfy both requirements simultaneously.

  1. Could you define the categories—referred to here as "Category G" and "Category I" that an "ideal auditor" should consider?
Questions for authors

N/A

1 comment

We thank the reviewer for recognizing our clear assessment criteria, the rigor of our evaluation, and the clarity of our presentation. Below, we address the reviewer’s comments individually.

W1. The verification target is not shown to be achievable, so low "robustness" is hard to interpret. The paper asks auditors to tolerate G and I changes drawn from an essentially unbounded class while still detecting INT8 quantization. One issue lies in "identifiability." Suppose a change—such as a modification to a hidden system prompt or a shift in the decoding method—alters the output distribution more significantly than the changes introduced by INT8 quantization or LoRA fine-tuning; in such a case, no functional transformation applied to the black-box output could satisfy both requirements simultaneously.

AuditGym evaluates how existing auditing methods perform under a specified verification contract. Its purpose is to characterize which requirements each method satisfies in the tested settings, without assuming that every requirement can be achieved simultaneously. Our evaluation measures sensitivity to model changes and robustness to the specified generation and interaction changes. Sections 3.1 and 3.2 define the user-specific contract and concrete interventions.

With known deployment ground truth, low robustness means that an auditor frequently rejects an unchanged model under a permitted change. This provides evidence for method selection without implying that every observed failure is avoidable. Section 3.3 also clarifies that non-rejection does not certify identity or establish that a change is undetectable.

A larger distribution shift from deployment settings does not alone establish impossibility, since deployment and model changes may affect different observable features. If different model specifications produce identical observable distributions under the permitted conditions, outputs alone cannot distinguish them. AuditGym evaluates existing methods under the selected contract without claiming universal identifiability.

W2. Could you define the categories—referred to here as "Category G" and "Category I" that an "ideal auditor" should consider?

Pref(⋅∣x)=P(⋅∣x;Mref,Gref,Iref).P_{\mathrm{ref}}(\cdot\mid x) = P(\cdot\mid x;M_{\mathrm{ref}},G_{\mathrm{ref}},I_{\mathrm{ref}}).

Ptgt(⋅∣x)=P(⋅∣x;Mtgt,Gtgt,Itgt).P_{\mathrm{tgt}}(\cdot\mid x) = P(\cdot\mid x;M_{\mathrm{tgt}},G_{\mathrm{tgt}},I_{\mathrm{tgt}}).

As defined in Section 3.1, these are the observable output distributions of the reference and target deployments for input x. The model specification M defines the learned parameters and their numerical representation; the generation policy G determines how output tokens are selected; and the interaction layer I constructs model inputs and coordinates model calls with tools and environment feedback. Section 3.2 specifies the controlled changes to these components. The examples below follow the categories in Table 10 in Appendix A.

ComponentSettings and examples
M Model specificationCheckpoint substitution, LoRA adapters, and quantization using INT8, FP4, NF4, AWQ, or GPTQ
G Generation policyTemperature and top-p, watermarking with KGW, SynthID-Text, TextSeal, or single-key Gumbel-max, and KGW strength
I Interaction layerSystem prompts, agent harnesses with tools and execution feedback, and retrieved context in the prior-work comparison

An ideal auditor is defined relative to a user-specific verification contract. It would detect changes that violate the promised model specification and accept permitted changes. Quantization should therefore trigger rejection when exact precision is promised, while an explicitly permitted quantized variant should be accepted. As clarified in Section 3.1, AuditGym evaluates existing methods against the selected contract and provides guidance for auditor selection and development.


If the above answers address the Reviewer's concerns, we would greatly appreciate it if they could consider increasing the rating. We are also happy to address any remaining questions.

Reviewer_EJ2pOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces AuditGym, a benchmark for testing whether black-box methods can verify the identity of the model served by an LLM API. The main idea is to separate changes to the model itself, such as checkpoint replacement, LoRA adapters, and quantization, from changes to generation settings or the interaction layer. The authors test four existing methods, MET, RUT, AgentProv, and LLMmap, across 19 checkpoints and seven groups of changes. They find that all four methods are good at detecting full checkpoint replacement, but several miss smaller model changes. More importantly, the methods often flag the same model as different when decoding settings, system prompts, or agent harnesses change. The paper argues that current audits often measure differences in behavior rather than model identity. AuditGym offers a shared test setting for studying this gap.

Critical strengths
  • The paper studies an important problem for people who use LLMs through APIs. Users usually cannot inspect the model weights, so they have limited ways to check whether a provider is serving the model it claims. This matters for trust, cost, and reproducibility, especially when models are used in larger systems. I like that the paper looks beyond the easy case of replacing one model with another. It also asks whether audits can detect smaller changes while ignoring harmless changes in how a model is used.
  • The experiments cover several types of changes that matter in practice. The authors study full checkpoint replacement, trained LoRA adapters, five quantization settings, decoding choices, watermarking, system prompts, and agent harnesses. They also evaluate four auditing methods across 19 checkpoints rather than focusing on just one method or model family. Tables 1 through 7 make it easy to see where each method works and fails.
Critical weaknesses
  • The main contribution is a benchmark, but the paper does not make a strong enough case for what is new compared with earlier controlled evaluations. The related work already discusses how decoding, system prompts, and wrappers can affect model auditing. It also mentions earlier benchmarks, including LeaFBench and KBF. AuditGym brings these ideas together under one definition of model identity, which is useful, but the paper could explain more clearly which new conclusions depend on this benchmark.
  • The definition of model identity is clear, but it is mostly a choice made by the authors. The benchmark treats any quantization or LoRA change as a different model, while allowing changes in decoding and system prompts. This is reasonable for checking an exact model specification, but not every API claim promises the same level of detail. More importantly, the paper does not fully discuss whether an auditor can separate M changes from arbitrary G and I changes using outputs alone. Without clear limits on allowed deployment changes, some cases may be impossible to tell apart.
Questions for authors
  • (Q1) Could the authors explain more clearly what AuditGym enables that existing benchmarks such as LeaFBench and KBF cannot?
  • (Q2) Why should all quantization changes be treated as model identity changes, even when an API provider explicitly allows quantized versions?
4 comments

We thank the reviewer for recognizing the practical importance of model verification for API trust, cost, and reproducibility, for appreciating our evaluation of subtle model changes alongside deployment robustness, and for acknowledging the breadth of our experiments and the clarity of our result tables. Below, we address all the reviewer’s comments individually.

W1/Q1. Could the authors explain more clearly what AuditGym enables that existing benchmarks such as LeaFBench and KBF cannot?

We compare AuditGym with prior evaluations in the table below and include this comparison as Table 10 in Appendix A of the revised paper. Overall, AuditGym provides the most comprehensive coverage across many settings.

✅ indicates inclusion. ❌ indicates that the setting was not included in the cited evaluation.

Evaluation settingLeaFBenchMETAgentProvKBFAuditGym
Configurable verification contracts❌❌❌❌✅
M Checkpoint substitution✅✅✅✅✅
M LoRA / PEFT✅❌✅❌✅
M Quantization✅✅✅✅✅
G Decoding settings✅✅❌✅✅
G Output watermarking❌✅❌❌✅
I System prompts✅❌✅✅✅
I RAG✅❌❌✅❌
I Agent harness❌❌✅✅✅

AuditGym also provides more detailed coverage within these settings. MET evaluates KGW, while AuditGym evaluates four watermark families and varies KGW strength. AgentProv studies agent-wrapper prompts, and KBF compares agent CLIs with API references. AuditGym additionally pairs reference-transfer tests with model substitutions inside a fixed harness and examines the effects of instructions, tools, and execution feedback separately.

We have clarified the following four contributions in the revised introduction.

  1. An explicit model-verification framework. We separate model specification (M), generation policy (G), and interaction layer (I), making sensitivity to model changes and robustness to permitted deployment changes jointly assessable. The framework supports user-specific verification contracts. This differs from LeaFBench's source-model attribution objective, under which a quantized or fine-tuned derivative can retain its source label despite changing the advertised model specification (Section 2 and Section 3.1).

  2. A benchmark with controlled deployment ground truth. AuditGym pairs deployments with known differences across seven change families and 19 checkpoints. The revised evaluation covers seven auditing approaches while preserving their access requirements. We release the code and collected responses so that methods can be compared against known model and deployment changes within a common testbed.

  3. New findings about the gap between auditing behavior and model verification. We show that existing auditors do not consistently satisfy the evaluated verification contract. Across seven methods, our experiments reveal missed model changes and false rejections under permitted deployment changes, including agent harnesses, demonstrating why checkpoint discrimination alone is insufficient for reliable model verification. For example, B3IT detects every tested checkpoint substitution but only two of twelve INT8 changes (Tables 1 and 2). Decoding, watermarking, and system prompts can cause auditors to reject unchanged models (Tables 3, 4, and 6). Successful substitution detection within a fixed harness can coexist with rejection of the unchanged model against a bare-model reference (Table 7).

  4. A community testbed for developing more reliable auditors. AuditGym provides a controlled setting for evaluating new auditing methods, including models deployed inside real agent harnesses. Its joint sensitivity and robustness measurements guide method selection for a user's verification contract and identify properties that future methods should improve. Section 4.4 explains these implications for auditor design.

W2/Q2. Why should all quantization changes be treated as model identity changes, even when an API provider explicitly allows quantized versions?

We thank the reviewer for highlighting the importance of service guarantees and the conditions under which model identity can be verified. We clarify these two points below.

1.The verification contract determines which changes are acceptable. AuditGym supports user-specific verification contracts. Our evaluation uses a contract that includes the checkpoint, learned adapters, and numerical representation. If a provider explicitly permits quantized variants, serving an allowed variant satisfies that contract.

Quantization changes the model specification, but this does not automatically constitute a contract violation. The measurements in Table 2 characterize desirable sensitivity when exact precision is promised and undesirable rejection when quantization is permitted. Section 3.1 and the revised introduction now clarify that users can specify permitted changes and assess the measured decisions accordingly. This allows the framework to support different service guarantees and guide auditor selection.

2.Our evaluation concerns specified deployment changes. AuditGym evaluates the concrete generation and interaction changes described in Section 3.2. It does not require an auditor to remain invariant under arbitrary transformations. If permitted deployments of different models produce identical observable distributions, outputs alone cannot distinguish them.

The benchmark measures how well existing auditors satisfy the selected contract under controlled deployment changes with known ground truth. These comparisons reveal demonstrated sensitivity and robustness and identify requirements for future methods. Section 3.3 clarifies that non-rejection does not certify model identity or establish that a change is undetectable.


If the above answers address the Reviewer's concerns, we would greatly appreciate it if they could consider increasing the rating. We are also happy to address any remaining questions.

Thank you for the detailed responses and clarifications. The comparison with LeaFBench, KBF, and other existing methods helps clarify the contribution of AuditGym. I also appreciate the explanation of configurable verification contracts, particularly how quantization can be treated differently depending on the provider's service guarantees.

These responses address most of my concerns about the benchmark's novelty and the definition of model identity. I think the additional comparisons and clarifications strengthen the paper, especially considering its focus on datasets and benchmarks. I am convinced with the authors responses and update my rating.

AuthorsOpenReview ↗

Thank you!

Dear Reviewer,

Thank you very much for the constructive feedback and for increasing the rating, we highly appreciate it. Your comments helped us improve the submission. We are glad that our detailed additional clarifications, the comparison with LeaFBench, KBF, and other existing methods, and the explanation of configurable verification contracts address your concerns. If you still have any questions, we are happy to answer them.

With kind regards,

The Authors

Comments on the paper

1 comment

We thank Reviewers EJ2p and vPzs for recognizing the practical importance of verifying the model behind an LLM API and the breadth of our controlled evaluation. Reviewer XdnF highlighted our well-motivated problem formulation, the usefulness of the M/G/I decomposition, and the relevance of including agent harnesses, while appreciating the finding that strong checkpoint discrimination does not ensure robustness to deployment changes or sensitivity to smaller model modifications. We also thank Reviewer Jad6 for praising our clear assessment criteria, rigorous evaluation, and clear presentation. Reviewer UUfy further recognized our explicit verification contract and careful experimental controls, and described the watermark asymmetry as a “genuinely new empirical result” with potential to motivate follow-up work.

Highlights of Our Rebuttal

To address the reviewers’ feedback, we made the following additions and revisions:

  1. Clarified AuditGym’s contributions and relationship to prior work. We added an explicit comparison with prior evaluations, including LeaFBench and KBF. We explain how AuditGym jointly evaluates sensitivity to model changes and robustness to permitted deployment changes. Our results demonstrate why strong checkpoint discrimination alone does not establish sensitivity to subtle modifications, robustness across deployment settings, or compatibility of references with agent harnesses.

  2. Clarified user-specific verification contracts and identifiability limits. AuditGym supports evaluation under different service guarantees. Our experiments instantiate a contract covering the checkpoint, learned adapters, and numerical representation; an explicitly permitted quantized variant would satisfy a broader contract. We also clarify that the benchmark evaluates specified deployment changes without claiming universal identifiability, and that non-rejection neither certifies identity nor establishes undetectability.

  3. Expanded the benchmark from four to seven auditing approaches. Beyond the reviewer-requested KBF evaluation, we added B3IT and a FLIPS-based verification adaptation, broadening the audit signals represented in the benchmark. The results reinforce the need to assess sensitivity and robustness together: B3IT detects all 182 checkpoint substitutions but only 2/12 INT8 changes, while KBF exhibits low rejection under many deployment changes but misses numerous checkpoint and adapter changes. We report valid-decision coverage explicitly.

  4. Clarified experimental setups and addressed implementation concerns. We clarified audit budgets, quantization configurations, decoding coverage, and the LLMmap verification adaptation. We also conducted additional calibration checks and corrected the identified quantization conversion issue, strengthening the reliability and transparency of the evaluation.

  5. Strengthened the agent-harness evaluation with additional controls. We added independent bare-model and matched-harness same-model controls, recalculated RUT results after excluding empty responses, and aligned AgentProv’s action extraction across bare and harness conditions. The revised results preserve the central finding: strong substitution detection within a matched harness can coexist with rejection of unchanged models against harness-free references.

  6. Added a controlled agent-harness component study. Using Mini SWE across five models and four auditors, we separately examined instructions, tool interfaces, and execution feedback. Instructions and tools produce more consistent rejections than execution feedback in this study. AgentProv accepts the addition of tools alone on all five models but rejects three when the same tools are added alongside instructions, showing that component interactions affect reference compatibility.

  7. Added a study connecting watermark utility and audit sensitivity. Across thirteen models, we evaluated GSM8K accuracy, MBPP pass@1, and generated-text perplexity alongside audit decisions. MET rejects all thirteen models under selected SynthID-Text and TextSeal settings despite small average changes on both tasks. These results show that high audit rejection need not indicate substantial task-performance degradation.

  8. Expanded reporting and prepared for reproducibility. We added per-comparison results and clarified configurations and decision coverage in the revised paper. We have prepared an accompanying results package with audit statistics, decision thresholds, configurations, and offline table-generation scripts so readers can reproduce the reported counts without rerunning model inference.

These revisions strengthen AuditGym as a controlled testbed for evaluating and developing model-verification methods under user-specific guarantees. We hope that these clarifications and additional experiments resolve the reviewers’ concerns. We thank the reviewers for helping improve our submission and welcome further questions.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.