AI uses for records
Private benchmark access control: who can see the test set before launch
By SourceX Editorial · Updated
10 sections
Short answer
Before launch, control a private benchmark by split and by role. A small custodian group holds items and answers; model developers see only a development split drawn from different companies, entities, periods and task families; the launch gate is run by people outside the team being judged; and gate scores are rationed and coarse. Release items only after the decision, under a written policy that retires whatever is published.
Evaluation split
Private benchmark access
Key takeaways
- Access control for a private benchmark is about splits and roles, not one locked folder: who sees development items, who sees gate items and who sees gate scores are separate decisions.
- Separate the people building the model from the people running the gate, and log every privileged read.
- Draw development and gate splits by company, entity, time and task family so that a development example cannot reveal a gate answer.
- Scores leak too: repeated queries against a holdout overfit it, so ration gate runs and report coarse results.
- Release items only after the launch decision, and retire anything released from the gate.
How should access to a private benchmark be controlled before launch?
Give each split its own audience. The custodians who build and adjudicate the benchmark see every item; model developers see a development split only; the gate split that decides the launch is run by people outside the team being judged, and its results reach that team as a small number of coarse scores. Nobody publishes items before the decision, and anything published afterwards leaves the gate.
That arrangement answers a narrower question than general data security. Storage controls, hosted API retention and leak response are covered in the guide to keeping a private evaluation set private. This page is the launch-gate policy: which people see which split and which scores at each stage, how the splits are drawn so one cannot reveal another, and when release is allowed.
The stakes are specific. A launch gate exists to answer whether this model, on work it has not been tuned toward, meets the bar. Every person, score or derivative that lets the development effort lean on gate material weakens that answer, usually without anyone intending it, and the weakness rarely shows until the model meets real users.
Why do scores leak even when items stay locked?
Every score a team sees tells it something about the hidden items, and enough adaptive queries let a team fit the holdout without reading a single item. Blum and Hardt describe exactly this on machine learning leaderboards: participants who repeatedly evaluate submissions against the holdout may begin to overfit it. They propose a leaderboard algorithm, the Ladder, designed to resist that overfitting, and test it on real submissions from a Kaggle competition.
Apply the same discipline to a launch gate. Decide in advance how many gate runs each candidate gets, report scores at the precision the decision needs rather than to several decimals, and do not return per-item or per-slice results from the gate to the team that builds the model. Per-slice diagnostics belong to the development split, where overfitting is expected and harmless.
The same applies inside an organization. A developer who can trigger the gate from a notebook will run it after every promising change, and within weeks the gate behaves like a second validation set. Put gate runs behind a request that an operator approves, and count runs per candidate in the decision log.
Separating the people who build the model from the people who run the gate
The person whose model is being judged should not be able to read the gate items, change the grader or rerun the gate at will. NIST SP 800-53 states the same principles for any system: separation of duties, with access authorizations defined to support it (AC-5); least privilege, allowing only the access needed for assigned tasks (AC-6); and logging the execution of privileged functions (AC-6(9)).
In an evaluation team that becomes four roles. Custodians write, adjudicate and store items. Gate operators run candidates against the gate split and report agreed scores. Model developers work on the development split. Approvers read gate scores and make the launch call. One person may hold two roles in a small team, but never developer and gate operator for the same candidate, and every read of gate items or rerun of the gate is logged with a reason.
Make the separation real in tooling. Keep gate items in a storage location whose access group contains only custodians and operators, run the gate from a pipeline developers can trigger only through an operator, and send gate outputs to a location developers cannot read. Review the access group at each phase change, because people who needed access during authoring often keep it long after.
Drawing splits so the development set cannot reveal the gate
A development split only protects the gate if no company, entity, period or task family appears in both. Random row splits fail this test on business records, where one customer's tickets, one vendor's invoices or one month's policy change shows up hundreds of times and a model learns the group rather than the skill.
At a glance
Drawing splits so the development set cannot reveal the gate
The scikit-learn documentation states the rule for grouped data: every sample in the validation fold should come from groups not represented in the paired training fold. For time-ordered data it recommends evaluating on future observations, because nearby records are correlated. Both rules apply directly to benchmark splits.
- Company: if records come from several businesses, hold out whole businesses for the gate so templates, product names and house style cannot carry over.
- Entity: group by customer account, vendor, case thread or device, and keep each group on one side; a ticket thread split across splits hands over its own answer.
- Time: draw the gate from a later period than development, and keep policy versions aligned so a rule change does not masquerade as a skill.
- Task family: hold out at least one family entirely if the launch claim is about generalization rather than performance on known tasks.
- Derivatives: check that summaries, embeddings, fine-tuning examples, attachments and grader rationales built from gate records are not stored anywhere developers can reach.
The access and release policy for evaluation data
Use one row per split and fill every column before the first candidate is evaluated. The entries below are an illustrative starting policy for a team of a dozen people; adjust names and allowances, but keep the structure. Gating on a dataset hub can implement the item column: on Hugging Face, for example, access requests are granted to individual users rather than whole organizations, and authors can switch from automatic to manual approval.
Give the policy an owner, a version and a date, and attach it to every launch decision it governs. When the policy changes, for example because a vendor exception moved items to semi-private, the decision log should show which version applied to which candidate, so a later reader can tell whether two gate scores were produced under the same rules.
| Split or tier | Who sees items | Who sees scores | Query allowance | Release rule |
|---|---|---|---|---|
| Development | Model developers and custodians | Anyone on the project, per item | Unlimited | May be shared with partners under the same license |
| Validation | Custodians only | Model developers, per slice | A fixed number of runs per week | Never released; refreshed each cycle |
| Gate (private) | Custodians and gate operators | Approvers, as one rounded score with an interval | A small fixed number of runs per candidate | Released only after launch, then retired from gating |
| Semi-private | As gate, plus named external vendors | Approvers and the vendor | Per contract | Treated as exposed; never used as the sole gate |
| Released sample | Public | Public | Unlimited | Published with a canary string and a retirement note |
| Retired | Custodians | Custodians, for drift checks | As needed | Kept for audit; never returned to gating |
Access by phase, from authoring to after launch
The policy changes as the benchmark moves through its life, so write who gains and loses access at each phase rather than one standing list.
At a glance
Access by phase, from authoring to after launch
- Authoring: custodians draft and adjudicate items from source records; model developers have no access, and source records used for the gate are fenced off from training pipelines.
- Development: developers work only on the development split; the validation split returns per-slice scores on a fixed schedule.
- Gate: operators run each candidate a fixed number of times, report the agreed score and interval to approvers, and log every run.
- Launch decision: approvers decide from gate scores and the validation trend; any request to see gate items is an exception under the rules below.
- After launch: custodians may publish a sample with a canary string, move published items to retired, and refresh the gate with new items. LiveBench shows one refresh model, adding and updating questions monthly from recently released sources so newer models meet unseen material.
Worked example: an illustrative support benchmark from three companies
This example is illustrative. A team builds a support-agent benchmark from licensed ticket histories of three companies. It places all of one company's tickets in the gate, and splits the other two companies' tickets by customer account into development and validation, so no account appears twice.
It then draws the gate from the most recent six months of the held-out company's history and development from earlier periods, after confirming the refund policy did not change at the boundary. One task family, warranty disputes, appears only in the gate, because the launch claim includes handling disputes the agent was not tuned on.
A derivative check finds that an earlier project had embedded all three companies' ticket summaries into a retrieval index the developers use. The team removes the gate company's summaries from the index and logs the removal; otherwise a developer's retrieval tool would have surfaced gate answers during development.
The exception arrives in week three: a vendor offering a hosted model can only be evaluated through its API. The team runs it on a semi-private copy of 50 gate items, marks those items exposed, and replaces them in the gate before the next candidate is scored.
At the decision meeting, approvers see one rounded gate score per candidate with its interval, the number of gate runs each used, the count of items moved to semi-private, and the validation trend. They do not see gate items. When one approver asks why a candidate failed warranty disputes, an operator shows three representative items under the exception rule, and those three are retired from the gate the same day.
Exceptions: when someone outside the gate group must touch items
Exceptions are normal; untracked exceptions are what break a benchmark. Grader bugs, legal review, a vendor that can only be reached through its own API and an approver who wants to see why a candidate failed all justify limited access, provided the access is logged and its cost is paid in items.
ARC Prize offers a public model of the bookkeeping: its semi-private evaluation set is so named because its tasks may have been exposed to limited third parties, for example through an API, while official scores come from a private set. Treat any gate item a third party has processed the same way: still useful for comparison, no longer clean enough to decide a launch alone.
Write the exception rule down. Show the smallest number of items needed, to the named person, in a session that is logged; record which items were shown; and move those items to semi-private or retired before the next gate run.
Signs the gate split is no longer private
Assume exposure when a gate score jumps without a matching change in development results, when access logs show reads outside the roles, or when a model completes a canary string or a near-verbatim gate item. Each is cheap to check and should be checked before every launch decision.
Canary strings help with the last test. BIG-bench put a canary string in every task file, including README and task.json files, to keep tasks out of web-scraped training data; a unique canary in your gate files lets you probe later whether a model saw them. A held-out comparison set helps with the first: Humanity's Last Exam keeps a private held-out set alongside its public questions to assess overfitting and gaming on the public benchmark, and a gap between the two is a warning sign.
Keep these checks on a schedule rather than waiting for a suspicious result. A short pre-decision review of the access log, the run count per candidate and a canary probe of each candidate model takes little time and turns a vague worry into a recorded finding either way.
If the evidence points to exposure, stop using the affected items for gating, rerun the gate on clean items for every candidate still under consideration, and record what changed in the decision log.
Sourcing records that keep a gate split clean
A gate split is easiest to protect when its source records have never been public and come with terms that name evaluation use. Records from a business that is not in any development data also make the company-level holdout possible.
Gate material from an outside business can be commissioned: SourceX looks for it among U.S. companies once a buyer asks, since nothing is held in stock. The supplying company approves the scope and terms and signs the agreement before any data is delivered, so evaluation-only use and handling expectations can be agreed before the first item is written.
Frequently asked questions
Who should have access to a private benchmark before launch?
Only the custodians who build it and the operators who run the gate should see gate items. Model developers should see a separate development split, and approvers should see gate scores rather than items.
Can model developers see gate scores?
They can see the agreed headline score after each permitted gate run, ideally rounded and with an interval. They should not see per-item or per-slice gate results, because repeated detailed feedback lets a team fit the holdout without reading it.
Can a summary, embedding or attachment built from gate records leak the answer?
Yes. Summaries, embeddings, retrieval indexes, fine-tuning examples and grader rationales built from gate records can all carry answers, so check every derived store developers can reach. Splitting by company, entity and time reduces the risk; removing derivatives closes it.
How many times can a candidate be run on the gate?
Set a small fixed number before the first run and keep it the same for every candidate. The exact number matters less than deciding it in advance, logging every run and never offering extra runs to a candidate that narrowly missed.
When can private benchmark items be released?
After the launch decision they support, and only as a sample marked with a canary string. Released items move to a retired tier and are replaced in the gate before it is used again.
Sources
- NIST SP 800-53 Rev. 5 defines separation of duties (AC-5), least privilege (AC-6) and logging privileged functions (AC-6(9)). Source
- Blum and Hardt show leaderboard participants who repeatedly evaluate on a holdout may overfit it, and propose the Ladder, tested on Kaggle submissions. Source
- scikit-learn recommends validation groups absent from the training fold and evaluation of time series on future observations. Source
- Hugging Face gated datasets grant access to individual users, with automatic or manual approval. Source
- BIG-bench task files carry a canary string to keep tasks out of web-scraped training data. Source
- ARC Prize calls an evaluation set semi-private because its tasks may have been exposed to limited third parties, such as through an API. Source
- Humanity's Last Exam keeps a private held-out set to assess overfitting and gaming on the public benchmark. Source
- LiveBench adds and updates questions monthly from recently released sources to limit contamination. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.