Two language models sit behind identical APIs. Model α and Model β each score 82 out of 100 on a public reasoning benchmark. Their answers, latencies and token budgets look similar. A procurement team concludes that the models have equal reasoning capability, then chooses the cheaper one.
A month later, a training manifest appears. Model α completed pre-training before the benchmark questions were written. Model β received a short instruction-tuning run containing paraphrases of thirty test items and their answers. Nothing in the score sheet recorded this difference.
Did Model β reason? It may have. Did Model α generalise? Perhaps. The score alone cannot tell us. The number is identical, but the evidence is not. The puzzle is not that benchmarks are useless. It is that we habitually treat the output of an entire causal pipeline as though it were a property engraved inside one model.
The likely intuition is simple: a test is a neutral window. It reveals whatever capability the model possesses. The hidden assumption is independence. We assume the test was not part of training, that the interface does not favour one model, that the scorer recognises equivalent answers, and that the tested task represents the capability named in the headline.
Remove any one of those assumptions and the meaning of 82 changes. This paper develops a practical response: preserve the score, but attach it to the history and interventions that make its interpretation possible.
Imagine a benchmark that is written one day after Model α completes training. The questions, answers and source documents did not exist during training. Now move the benchmark’s publication date two years backwards while keeping every item unchanged. The model, prompt and score remain fixed. Only possible exposure changes.
Should the capability claim remain equally strong? No. The behaviour is the same, but the rival explanation of memorised or indirectly learned test content becomes available. A causal property of the evidence changed even though no output changed. This is why provenance belongs inside the evaluation claim rather than in a separate compliance appendix.
A ten-question example
A model answers six of ten genuinely novel questions correctly. Two additional questions appeared with answers in its final tuning set. It reproduces both. The public score is eight out of ten, or 80 per cent.
If we silently read 80 per cent as “probability of solving a new problem from this task family”, we assume the exposed items behave like independent samples. Remove them and the clean estimate is six out of eight, or 75 per cent. That five-point difference is not the deepest problem. With only eight clean items, uncertainty is wide, and the exposed answers may have also taught a reusable strategy that affects the remaining items.
The correct response is not to subtract a universal contamination penalty. It is to state two observations: configured score 80 per cent; clean-subset score 75 per cent on eight items. Then test a post-cutoff or independently generated set. Contamination changes the estimand, rather than only the decimal.
Real corpora make the boundary harder. Duplicate and near-duplicate material can travel through mirrors, derived datasets and synthetic transformations. Analysis of C4 found examples from evaluation datasets inside a large web corpus.[4] Deduplication research found substantial repetition, reduced memorised emissions and reduced train-test overlap when duplicates were removed.[5] Controlled contamination studies further distinguish exposure to input text from exposure to the ground-truth answer, and show that simple n-gram definitions miss important cases.[6]
Published evidence: data mixture, duplication and test exposure can change measured performance. Contested interpretation: a high score on an exposed item may still involve useful computation, so exposure does not prove pure memorisation. Practical consequence: unknown exposure lowers the permitted claim; it does not establish cheating.
Provenance has more than one layer
Dataset documentation proposals such as Datasheets for Datasets and model documentation proposals such as Model Cards were designed to make motivation, composition, intended use and evaluation conditions visible.[7][8] The Data Provenance Initiative later audited more than 1,800 text datasets and found extensive missing or erroneous licensing metadata, illustrating how difficult lineage reconstruction can be at scale.[9]
For evaluation validity, however, provenance must go beyond legal source and licence. It needs at least five layers: source documents, transformation and filtering, training mixture and order, post-training datasets and objectives, and known or tested contact with benchmark materials. A model identifier without these layers is like a medicine label that names the bottle but omits the dose and manufacturing batch.
Suppose two models have equal architecture and equal final benchmark score. Model α learned from broad examples and never saw the task template. Model β learned from narrow examples that closely match the benchmark. Now swap only their training histories while preserving the final score through additional optimisation.
The score cannot reveal which route produced the behaviour. Yet the route matters for transfer. Change the domain vocabulary, remove answer choices or ask for an explanation, and the models may diverge. The intervention is not designed to punish memorisation. It asks whether the regularity that supports the score survives when benchmark-specific supports are removed.
flowchart LR A["A score carries a hidden history"] --> B["The exam is part of the machine"] B --> C["Build evidence by changing one<br/>cause at a time"] C --> D["The audit under pressure"] D -. "re-test" .-> A classDef first fill:#0a1424,stroke:#087A98,stroke-width:2px,color:#e6f3ff classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff class A first class B,C,D step
The exam is part of the machine
Training history is only half the causal path. The evaluator also builds a temporary system around the checkpoint. A chat template inserts roles and delimiters. A prompt defines the task. Few-shot examples provide a local curriculum. Decoding chooses one trajectory from a distribution. A parser converts text into a label. A metric decides which differences count.
The benchmark is not a passive window. It is an instrument coupled to the model. Changing the instrument can expose a genuine weakness, create an artificial one, or simply measure a different behaviour.
Here, Dpre is pre-training data, while order captures curriculum and repetition. The objective includes the training loss, and Dpost is post-training data. Together they produce checkpoint θ. Runtime function R generates under a prompt, examples and decoding rule. Function A parses and scores that output to produce the published number S.
The equation is useful only because it prevents a shortcut. A single value of S cannot identify which input caused the result. To learn more, hold the checkpoint fixed while prompts and scorers vary. In another experiment, hold the recipe fixed while exposure changes, or preserve the task demand while surface form changes.
The benchmark has a lifecycle
Evaluation datasets are often public because openness supports inspection and reproducibility. That same openness creates time-dependent exposure. Source passages may predate the benchmark. Draft items may circulate in repositories. Evaluation prompts may later enter logs used for training. Post-training datasets may adapt benchmark formats even when exact items are absent.
A useful provenance record therefore asks when each material became available and when each model stage ended. A model trained before item creation has a stronger independence case than one trained after public release. A private test is stronger still only if its source material, annotators, generation process and access controls also resist indirect exposure.
Exposure is a distance, not a switch
“Seen” and “unseen” are too coarse for serious inference. Exact exposure means the item and answer were available together. Near-duplicate exposure preserves most wording or structure. Source exposure makes the underlying passage, table or code available without the authored question. Procedure exposure supplies worked examples that teach the same transformation while changing all surface content. These distances create different rival explanations.
Exact answer exposure makes direct reproduction plausible. Source exposure may merely remove a knowledge-retrieval burden while leaving the requested inference novel. Procedure exposure can teach a genuinely reusable skill, yet still make a benchmark a poor estimate of unaided transfer. For that reason, a contamination report should not collapse every overlap into one percentage. It should name the unit of contact, the training stage, whether answers were present, and the transformation separating training from test.
String-level novelty is only one kind of independence. When the intended claim concerns transfer, the decisive comparison is often a source-swapped or post-cutoff task that preserves the causal demand while replacing the materials that may have been learned.
One question, three instruments
Multiple-choice evaluation makes the interface problem concrete. A system can be asked to emit a letter, to generate the full answer text, or to rank option likelihoods. Those methods are not interchangeable for an instruction-tuned model.
Few-shot example order has produced large swings in earlier language-model evaluations.[10] Option order can also alter multiple-choice performance, with one study reporting sizeable gaps across models and benchmarks.[11] Yet a later analysis found that some apparent prompt sensitivity came from rigid matching and first-token likelihood scoring rather than from the model’s semantic answer.[12] Another study similarly showed that generated text can be more robust than first-token selection when the two disagree.[13]
These results do not cancel one another. They separate two mechanisms. A model may genuinely depend on superficial order. An evaluator may also mis-score a stable answer. Interface sensitivity and scoring sensitivity are different failure modes.
Take forty synthetic science questions and run one fixed checkpoint with one fixed prompt. An exact parser marks 29 answers correct. A rubric-guided semantic scorer marks 35 correct. Human adjudication of the six disagreements finds that five answers express the right concept but violate the requested letter format; one answer sounds plausible yet changes the scientific relation and should remain wrong.
The evidence now supports two measurements, not one corrected “true score”. Semantic task accuracy is 34 out of 40. Strict schema compliance is 29 out of 40. If the model will advise a reader, the first may be closer to the intended construct. If it must drive a typed workflow, the second is an operational defect. The disagreement review prevents a parser weakness from being called ignorance and prevents fluent wording from being called correctness.
Keep the checkpoint and question fixed. First require the token “B”. Next require the full phrase “sodium chloride”. Finally ask for a one-sentence explanation with no options. Suppose the model fails the letter task, succeeds on the phrase, and explains the chemistry correctly.
Which result measures knowledge? The answer depends on the deployment demand. If the system must fill a machine-readable form, letter or schema compliance matters. If the claim is chemical knowledge, rigid letter matching may undercount it. The interface is not noise to be optimised away. It is part of the construct definition.
generated text: “Sodium chloride, because dissolved ions carry charge.”
Three verdicts
First-token rank: wrong, because A has the highest local probability.
Exact text parser: correct if it extracts “sodium chloride”.
Instruction compliance: wrong if the contract required one letter only.
Construct validity comes before leaderboard validity
A benchmark name often does more rhetorical work than its items. “Reasoning”, “truthfulness”, “agency” or “medical competence” may each cover several distinct capacities. A multiple-choice item can require knowledge, language parsing, option comparison, calibration, refusal behaviour and format compliance. A single accuracy score cannot reveal which component failed.
A large systematic review of 445 language-model benchmarks found recurring gaps in construct definition, format control, contamination preparation, uncertainty reporting and error analysis.[14] HELM takes a complementary approach by evaluating multiple metrics in shared scenarios rather than treating accuracy as the only desideratum.[15]
Validity belongs to an interpretation and use, not to a dataset name. “Model α scored 82 under configuration K” is a direct observation. “Model α can reason” is an inference. The second sentence requires a bridge: task coverage, rival controls, stable performance under equivalent forms, and evidence that the bridge matters in the intended setting.
Consider a synthetic “clinical reasoning” test with sixty recall items, twenty-five information-extraction items and fifteen treatment-choice items under uncertainty. Model α answers 58, 22 and 4 correctly. Model β answers 52, 20 and 12 correctly. Both score 84 out of 100.
The aggregate ranking declares a tie. The component profile does not. For searching a reference manual, Model α may be preferable. For drafting a plan that must surface uncertainty, Model β may deserve further testing, although neither result alone establishes clinical safety. Change only the item mixture and either model can win the leaderboard without changing at all. The benchmark’s weighting function has changed the headline.
This is why construct work precedes metric work. The evaluator must specify which errors are substitutable, which are safety-critical, and which deployment decisions the total is meant to inform. An average is meaningful only after those choices are defended.
Build evidence by changing one cause at a time
The practical mistake is to ask whether a benchmark is valid in the abstract. The better question is: what is the strongest claim this particular run can support? The answer should change when evidence about training, interface or transport changes.
I propose a decision instrument called the Capability Evidence Envelope. It does not produce a universal validity score. It defines the region of claims still open after four gates and a reproducibility foundation.
Construct gate
Does the task isolate and represent the capability being named? Are format demands and sub-capabilities explicit?
Exposure gate
Can exact, near-duplicate, source-level and semantic contact with test material be bounded?
Interface gate
Does the result survive meaning-preserving prompts, option order, decoding choices and validated scoring?
Transport gate
Does the evidence travel to a new time, population, tool environment or real operating distribution?
Beneath all four sits a receipt layer: model and adapter identifiers, data manifests, task version, prompt, chat template, tool configuration, decoding parameters, parser, metric, raw outputs and uncertainty calculation. Without receipts, even the narrow configured-run claim may not be reproducible.
The envelope uses a weakest-link rule, not an average. Excellent prompt robustness cannot compensate for unknown test exposure. A pristine time split cannot make a poorly defined construct meaningful. Deployment shadowing cannot rescue an irreproducible scoring script.
A claim ladder, not a quality score
The envelope widens through five statements. At the narrowest level, the evaluator has an observation: this run produced this score. With complete receipts and uncertainty, the result becomes reproducible configured performance. Stability across equivalent prompts, parsers and clean task variants supports benchmark-task performance. A defended construct bridge permits capability-relevant evidence. A representative time, domain or operating shift permits deployment-relevant evidence.
Each step answers a different counterfactual. Would another evaluator reproduce the result? Would equivalent wording preserve it? Would a different task form that demands the same capacity preserve it? Would the result survive the change that matters outside the laboratory? A failure does not erase the narrower statement. It identifies the boundary at which the claim stops.
The weakest-link rule follows from that logic. Suppose construct, exposure, interface and receipts are all rated three on a three-point scale, while transport is zero. Their average looks excellent. Yet no evidence addresses the target environment. Averaging would let unrelated strengths purchase a missing premise. Evidence gates are conjunctions: a deployment claim is only as wide as the least-tested necessary bridge.
This design also prevents ritual auditing. Teams need not maximise every gate for every decision. They choose the claim needed, identify its necessary gates and run the smallest intervention that could lower it. The instrument turns missing evidence into a next experiment rather than a vague caution label.
A small factorial experiment
Suppose we can train two small checkpoints with the same architecture and recipe. The clean checkpoint excludes a benchmark family. The exposed checkpoint receives paraphrases of part of that family during post-training. We then cross two prompt forms with two scorers.
Use a balanced set of two hundred items, randomise item and option order, hold decoding fixed and retain every generated answer. Estimate the exposure effect, prompt effect, scorer effect and their interactions, with uncertainty from item-level resampling. The design assumes that the checkpoints differ only in the planned post-training exposure and that human reviewers judge the paraphrases to preserve task demand and difficulty closely enough for comparison.
A large exposure-by-prompt interaction would permit the statement that the canonical advantage depends partly on benchmark form. A small interaction with stable post-cutoff performance would weaken that explanation. A null result would not prove absence of contamination, especially with low power or ineffective transformations. It would show only that this intervention failed to reveal a consequential dependency.
Under canonical prompts and exact scoring, exposure appears worth sixteen points: 84 minus 68. Under paraphrased prompts, the advantage is five points: 66 minus 61. The difference-in-differences is eleven points.
That eleven-point interaction is evidence that benchmark-specific familiarity contributes to the canonical advantage. It is not a proof of verbatim memorisation. The paraphrase may be harder, and post-training may have taught a task strategy that partly transfers. A stronger study adds several human-validated paraphrases, source-swapped items and a clean post-cutoff set.
The point is methodological: interactions identify mechanisms better than isolated leaderboard deltas. A model that remains strong across equivalent forms supports a broader task claim. A model whose advantage collapses under one controlled change supports a narrower configured-path claim.
A realistic configured-system example
A bank wants to compare two language models for routing customer emails. The target is not “general reasoning”. It is correct routing among twelve queues, calibrated abstention on ambiguous cases, and stable performance on new products.
The evaluation team builds a time-split dataset from messages created after both models’ declared training cutoffs. It keeps the final 20 per cent private, checks source systems for duplicated templates, and records possible exposure to public policy documents. Each model is tested with six meaning-preserving instructions, two option orders and both schema validation and adjudicated semantic scoring. Raw outputs and model version identifiers are retained.
On the public-like set, Model α leads by four points. On the hidden time split, the lead shrinks to one point and its abstention calibration worsens. Model β is slightly less accurate but more stable across prompts and new products. The decision is no longer “which model has higher intelligence?” It is “which configured system meets routing and abstention requirements under the expected distribution?”
This is a synthetic scenario, not a reported deployment. Its value lies in the structure: narrow construct, bounded exposure, interface perturbations, transport slice, uncertainty and receipts.
Capability Evidence Envelope audit
Select the evidence available for one reported result. The tool returns the strongest claim type currently permitted, the weakest gates and a machine-readable certificate. It deliberately avoids an averaged validity score.
No assessment yet
Choose the evidence available, then assess the claim.
How to use a positive or negative result
A positive audit does not prove an intrinsic, context-free capability. It permits a stronger statement within the tested envelope. For example: “Model α shows stable routing performance across six instructions, two scorers and a post-cutoff domain shift.” That sentence is less dramatic than “Model α understands customer intent”, but it is actionable.
A negative audit is not a verdict that the model lacks the capability. It identifies the next discriminating test. Unknown exposure calls for a time-split or provider-side overlap report. Prompt instability calls for equivalent interfaces and error review. Weak construct coverage calls for task decomposition. Poor transport calls for shadow evaluation or a new domain slice.
The instrument cannot establish consciousness, understanding in a metaphysical sense, or a unique internal mechanism. It is a method for bounding behavioural and operational claims. It should not be used to turn missing disclosure into a numerical accusation.
Typed certificate and decision logic
The embedded audit exports a JSON object with gate levels, permitted claim, blockers and next tests. The logic is ordinal. It never averages a severe gap away.
from dataclasses import dataclass, asdict
from typing import Literal
Claim = Literal[
"observation only",
"reproducible configured performance",
"stable benchmark-task performance",
"construct-relevant capability evidence",
"deployment-relevant capability evidence",
]
@dataclass(frozen=True)
class Evidence:
construct: int # 0..3
exposure: int # 0..3
interface: int # 0..3
transport: int # 0..3
receipts: int # 0..3
uncertainty: int # 0..3
def permitted_claim(e: Evidence) -> Claim:
if e.receipts == 0:
return "observation only"
if min(e.receipts, e.uncertainty) < 1:
return "reproducible configured performance"
if min(e.exposure, e.interface, e.receipts, e.uncertainty) < 2:
return "reproducible configured performance"
if e.construct < 2:
return "stable benchmark-task performance"
if e.transport < 2:
return "construct-relevant capability evidence"
return "deployment-relevant capability evidence"
if __name__ == "__main__":
evidence = Evidence(construct=2, exposure=3, interface=2,
transport=1, receipts=2, uncertainty=2)
print({**asdict(evidence), "permitted_claim": permitted_claim(evidence)})
Run with Python 3.10 or later. Replace the example levels with your audit results. A higher output tier permits a broader claim; a lower tier identifies missing evidence. The script cannot judge whether your evidence deserves the level you assigned.
stateDiagram-v2 [*] --> Claim state "Why one number cannot recover<br/>its cause" as Claim state "A ten-question example" as Test state "Provenance has more than one layer" as Revision Claim --> Test: expose mechanism Test --> Decision: evidence survives Test --> Revision: rival survives Revision --> Claim: narrow or rebuild Decision --> [*]
The audit under pressure
The envelope is useful only if it survives adversarial and inconvenient cases. The hardest case is not exact leakage. It is transformed exposure that preserves the answer-bearing structure while defeating simple detectors.
Research on contamination detection has shown that rephrased benchmark samples can evade several existing detection approaches while still improving measured performance, including reported gains of up to fifteen percentage points in the studied settings.[17] A later review of reporting practices found that only a minority of thirty surveyed model releases supplied enough training-data or overlap information to contextualise public-test results.[18]
Exact-match cleanliness is not semantic independence. A benchmark item can be novel at the string level while its source passage, solution trace, template or translated form appears in training. Conversely, a shared source does not automatically invalidate the test. A model may need to transform familiar facts in a genuinely new way. The evaluation must state which kind of novelty matters.
Imagine a fifty-item arithmetic benchmark derived from a public textbook. Fine-tuning contains the textbook’s worked examples and solution methods, but no benchmark question appears verbatim. An exact-match scan reports a clean test. The configured model answers 44 canonical items correctly.
Now preserve each required operation while replacing the story, quantities and source chapter. Accuracy falls to 31. On thirty newly authored post-cutoff items it reaches 30. This pattern does not prove that the canonical answers were copied. It shows that the 44-point result mixed task ability with support supplied by familiar source structure. The defensible claim narrows from broad arithmetic transfer to strong performance on the canonical family, followed by moderate performance under source replacement.
Three boundaries that prevent overcorrection
First, unknown provenance is not proof of invalidity. It is missing information. The permitted statement becomes narrower: a reproducible score under a named configuration, with exposure uncertainty disclosed. This distinction matters because accusation and scientific caution are not the same act.
Second, a hidden benchmark is not automatically valid. Hidden items can still misrepresent the construct, contain annotation errors, share public source material or reward brittle shortcuts. Secrecy protects one exposure path. It does not validate the task.
Third, an LLM judge is not a neutral oracle. Semantic grading can reduce exact-match artefacts, as some prompt-sensitivity research suggests, but the judge introduces its own prompt, model version, preferences and failure modes. Human adjudication of disagreements, rubric validation and multiple scoring paths remain necessary when the result matters.
A model achieves 92 per cent on a benchmark of well-edited English support tickets. Keep the weights, prompt and scorer fixed, but move the system to a queue containing code-switched messages, screenshots, new product names and customers who omit key facts.
Nothing about training contamination changed. Yet the operational claim may fail because the benchmark did not represent the new environment. This is the transport gate. A capability can be genuine within one task distribution and insufficient elsewhere. Generalisation is always generalisation across a named change.
Perhaps “capability” is simply a disposition of the whole configured system, including prompts and tools. On this view, there is no error in attributing the score to the system rather than the checkpoint. That alternative is often correct. The paper’s claim still stands: the system boundary and configuration must be named. Problems arise when a result from one boundary is transported to another without evidence.
For mature public benchmarks, model ranking stability across post-cutoff source-swapped items will predict deployment transfer better than the original headline score. The hypothesis strengthens if ranking stability correlates with later real-world performance across domains. It weakens if canonical scores predict transport equally well after controlling for compute and model family. A rival explanation is that the new items are simply better labelled or more difficult. The smallest useful test is a preregistered three-model comparison on canonical, transformed and genuinely post-cutoff sets.
What the envelope cannot buy
No practical audit can recover a fully opaque training history from outputs alone. Black-box contamination tests depend on assumptions about memorisation, probability access and model behaviour. Provider-side reports can also be incomplete or use incomparable overlap definitions. The best available conclusion may remain conditional.
Nor can controlled behavioural variation uniquely identify an internal algorithm. Stable performance across paraphrases supports robustness, not a specific reasoning circuit. A collapse under format change reveals dependence, but not whether the cause is tokenisation, attention allocation, post-training preference or parser behaviour. Mechanism claims require separate causal interventions inside the model.
The envelope is intentionally conservative. Its purpose is not to make every evaluation expensive. It helps match expense to consequence. A low-stakes prototype may need a reproducible configured score and error sample. A clinical, financial or safety claim may justify private time splits, overlap reporting, multi-interface testing, uncertainty and operating evidence.
sequenceDiagram participant Q as Question participant M as Mechanism participant E as Evidence participant D as Decision Q->>M: A score carries a hidden history M->>E: Why one number cannot recover its cause E-->>M: compare rival explanations E->>D: Widen the claim only after a stronger intervention D-->>Q: revise scope or act
Widen the claim only after a stronger intervention
When a new model report announces a capability, do not begin by debating whether the number is impressive. Ask what causal path produced it and which alternative paths were tested.
Request the configured-system manifest, rather than only the model name. Separate pre-training evidence from post-training elicitation. Ask whether benchmark source material could have entered any training stage. Re-run equivalent prompts and scoring methods. Inspect disagreements. Use a time, domain or population shift that matches the intended decision. Preserve raw outputs and uncertainty.
Then write the conclusion at the width the evidence permits. “This run scored 82” may be all that survives. With better receipts and interventions, the statement can widen to stable task performance, construct-relevant evidence, or deployment-relevant capability.
The decision rule is simple: publish the broadest claim that survives every relevant intervention, not the broadest noun suggested by the benchmark’s title.
This changes model selection as well as scientific reporting. Choose the model whose evidence envelope contains your operating need. A lower headline score with clean lineage, stable interfaces and transport evidence can be more decision-worthy than a higher score whose causal path is unknown.
For a researcher, this means pre-registering the noun in the claim before seeing the score. “Performance on these items” requires less than “reasoning”, and “reasoning in this workflow” requires different evidence again. For a buyer, it means comparing evidence envelopes rather than copying leaderboard order. For a system owner, it means treating prompt, tool, parser, policy and model updates as possible changes to the evaluated system, not harmless configuration drift.
A benchmark can then function as a contract rather than a trophy. The contract names the configured system, task demand, population, time boundary, interface, uncertainty and permitted inference. When any of those changes, the owner can identify which evidence remains valid and which gate must be reopened. The useful unit of progress is not a higher isolated score, but a wider claim that survives a stronger intervention.
Glossary
- Training provenance
- The traceable lineage of source data, transformations, mixture, order, objectives, post-training and possible benchmark contact.
- Contamination
- Training exposure to evaluation items, answers, source material or meaning-preserving derivatives in a way that affects interpretation of the score.
- Construct validity
- The adequacy of the bridge from observed task performance to the capability or phenomenon being claimed.
- Evaluation interface
- The prompt, examples, chat template, tools, decoding, parser and metric that couple a checkpoint to a score.
- Transport
- The extent to which an inference holds across a named change in time, domain, population, task form or operating environment.
- Receipt
- A versioned artefact that permits reconstruction or independent checking of an evaluation run.
- Capability Evidence Envelope
- The bounded set of claims permitted by construct, exposure, interface, transport and reproducibility evidence.
References
- Li, J. et al. (2024). DataComp-LM: In search of the next generation of training sets for language models. Advances in Neural Information Processing Systems.
- Xie, S. M. et al. (2023). DoReMi: Optimizing data mixtures speeds up language model pretraining. Advances in Neural Information Processing Systems.
- Chung, H. W. et al. (2022). Scaling instruction-finetuned language models.
- Dodge, J. et al. (2021). Documenting large webtext corpora: A case study on the Colossal Clean Crawled Corpus. EMNLP.
- Lee, K. et al. (2022). Deduplicating training data makes language models better. ACL.
- Jiang, M. et al. (2024). Investigating data contamination for pre-training language models.
- Gebru, T. et al. (2021). Datasheets for datasets. Communications of the ACM.
- Mitchell, M. et al. (2019). Model cards for model reporting. FAT*.
- Longpre, S. et al. (2023). The Data Provenance Initiative: A large scale audit of dataset licensing and attribution in AI.
- Lu, Y. et al. (2022). Fantastically ordered prompts and where to find them. ACL.
- Pezeshkpour, P. and Hruschka, E. (2024). Large language models sensitivity to the order of options in multiple-choice questions. Findings of NAACL.
- Hua, A. et al. (2025). Flaw or artifact? Rethinking prompt sensitivity in evaluating LLMs. EMNLP.
- Wang, X. et al. (2024). Look at the text: Instruction-tuned language models are more robust multiple choice selectors than you think.
- Bean, A. M. et al. (2025). Measuring what matters: Construct validity in large language model benchmarks.
- Liang, P. et al. (2022). Holistic evaluation of language models.
- Biderman, S. et al. (2024). Lessons from the trenches on reproducible evaluation of language models.
- Dekoninck, J. et al. (2024). Evading data contamination detection for language models is (too) easy.
- Schaeffer, R. et al. (2024). Language model developers should report train-test overlap.