A benchmark for lab-in-the-loop agents: agents that choose which costly measurement to buy next, get assay-realistic results back, and are scored on whether the feedback loop earned anything.

This repository is the design package, not the instance data. It holds the specification, the frozen rule definitions as executable code, the construction and verification scripts, and the measured supply figures. It deliberately does not redistribute the three upstream datasets — see Data below.

What "lab-in-the-loop" means here

Most benchmarks that call themselves closed-loop are retrieval benchmarks with a loop drawn around them. This one defines the term operationally, as seven conditions (C1–C7 in the spec), and the seventh is load-bearing:

C7 — loop necessity. For every released instance, a scripted closed-loop policy must beat the same policy run open-loop. Instances that fail this screen are discarded, not shipped with a caveat.

Without C7 an "agentic lab" benchmark cannot distinguish an agent that uses feedback from an agent that happens to have a good prior. With it, every instance is one where feedback demonstrably matters.

Scoring

Not binary success. The primary metric is the normalised discovery-curve AUC — confirmed successes integrated against the fraction of budget spent — reported as

loop_gain = AUC(agent) − AUC(open-loop control)      # same instance, paired

This was chosen on measured signal-to-noise, not taste. At a 96-request budget the binary metric's SNR falls to 0.78 and loses the effect entirely, while the curve AUC holds at 3.44:

budget	binary SNR	curve-AUC SNR
16 requests	2.74	4.40
96 requests	0.78	3.44

Budget is a declared axis, scored at 16 / 48 / 96 requests, because arm ordering inverts across it (one arm pair goes from +0.400 to −0.050). A single budget would hide that.

Domains

Three domains, one rule shape. Every clause is a conjunction of the same four parts, and every stored value follows a single convention — larger is better — with any direction change applied at build time rather than in the scoring code.

domain	activity	counter-screen	replicate	orthogonal
antibiotic (CO-ADD)	inhibition ≥ 80%	two fungal screens ≤ 50%	n≥2, value−sd ≥ 80	isogenic tolC / lpxC
regulatory DNA (GSE114002)	ribosome load, pseudouridine arm	out-of-frame uAUG absent	independent library batch	N1-methyl-pseudouridine, identical sequence set
antibody (AlphaSeq)	pKd ≥ threshold	negative-control binding	n≥2 replicates	replicate holdout only

Two honest limitations, stated up front

The antibody specificity clause is non-binding. Of the top 1% by affinity with ≥2 replicates, 719 of 719 also clear the negative-control filter. It removes nothing. That domain matches the four-clause shape while behaving as a three-clause rule. It also has no orthogonal target — every on-target row is one target — so its fourth clause is a replicate holdout, which is a weaker claim than orthogonality and is labelled as such in domains.py.
The DNA counter-screen, by contrast, binds hard: 39.3% of the library carries an out-of-frame upstream AUG.

Supply, measured

Disjoint capacity — instances that can be cut with no shared findable answer, after grouping answers (Bemis–Murcko family / UTR motif / CDRH3):

domain	winner groups	@6 answers	@8	@12
regulatory DNA	2,175	363	272	181
antibody	952 CDRH3	325	259	192
antibiotic	303 `target:family`	69	52	36
total		757	583	409

Operating point: 8 answers per instance, 583 candidates for 400 released, leaving 1.46× headroom for C7 rejections. The antibiotic domain has no headroom at that setting; see spec §4 for what happens if C7 rejects any of it.

Three defects found in v0.1, and reported

A mislabelled intermediate column. ground_truth.csv shipped both is_success (26 compounds, the real four-clause conjunction) and pass_confirmation (88 compounds), which does not enforce selectivity — counter-screen values up to 150% sit among those 88. Nothing marked the second as an intermediate and an entire analysis line ran against the wrong column before the discrepancy surfaced.
The 20 E. coli instances re-use the same answers. Measured disjoint capacity for that target is 3 instances at 6 answers each; v0.1 cut 20. The per-campaign results stand (each was scored independently against is_success), but "20 independent problems" does not. The statistical consequence was measured rather than assumed: arm-agreement against winner-set Jaccard overlap gives r = −0.037 [−0.187, +0.113], i.e. no detectable outcome correlation. That is an empirical result about these 20 instances, not a licence to re-use answers at scale.
The primary metric moved with the CPU allocation. The released board ran under --cpus-per-task=4. The same campaign (inst_01 arm B) under 2 gave n_actives_found 3 instead of 4, and with it a different method_ap_last_round (0.52067 → 0.55768) and unqueried-pool AUROC (0.5009 → 0.76021). Two repeats at 4 threads reproduced 4 exactly, so the harness was deterministic given a thread count and sensitive to it: multi-threaded BLAS changes the reduction order, the last bits of a model coefficient move, and two candidates whose acquisition scores agree to ~1e-15 swap in the ranking. One campaign in twenty-one sat close enough for this to reach the primary metric. This is the worst of the three — the other two left the reported numbers correct, this one made a number an artifact of the hardware, and it is invisible to anyone who always runs with the same allocation. harness/determinism.py pins every thread pool to one thread before numpy loads, verifies the pools with threadpoolctl rather than trusting the environment variables, and quantizes scores to 1e-9 before any of the four ordered decisions in the runtime path. Both are deliberate behaviour changes, so what they did to the released numbers was measured rather than assumed: 21 campaigns across 3 instances, all seven arms, re-run at the board's exact operating point under 1, 2 and 4 CPUs. All three allocations agree on all 2,415 non-volatile fields, and all three also match the released board on all 2,415 — inst_01/B returns to n_actives_found = 4 at every allocation. The fix removed the sensitivity without moving any value it was tested on. That is 21 of the board's 300 campaigns, 3 of its 20 instances — 7%; the rest has not been re-run, and another instance may sit on a knife edge that quantization resolves the other way. Spec §6.3 has the full account.

Verification

Every factual number in domains.py and the spec is recomputed from raw data by analysis/verify_claims.py, which exits non-zero on any disagreement. This is not decoration: on its first run it caught three wrong claims of ours — a mis-identified replicate structure, an antibody count computed at the wrong aggregation level, and a bad file path. The corrections are recorded in domains.py as comments next to the values they replaced.

analysis/verify_refactor.py compares every field of every campaign score against the released run, to full float precision, so that generalising the harness across domains cannot silently move the antibiotic numbers. It is what found defect 3: it reported six differences that looked like a broken refactor and turned out to be the thread count, which inspection would not have caught and a summary statistic would have averaged away.

analysis/verify_determinism.py gates the fix for that defect. It runs the same campaigns under genuinely different --cpus-per-task values, with each job script still exporting the hostile OMP_NUM_THREADS the old scripts used, and requires every non-volatile field to be identical across all of them. It prints the thread pools each run actually observed, and the push gate re-checks that the compared runs really had different allocations — a determinism pass that cannot show the conditions differed proves nothing.

It also requires, via --match-config, that the compared runs used the board's operating point. This is not hypothetical rigour: the first run of this gate passed at the harness defaults (400 requests per round, not the board's 2) and so never exercised the near-tie the defect lives in — at 400 the campaign queries most of the pool regardless of a 1e-15 swap. A passing gate at the wrong operating point is harder to catch than a failing one, and the only tell was inst_01/B reporting 14 actives where the board reports 4. The weak run is kept as results/verify_determinism_wide_budget.json as evidence the fix also holds at a looser budget, but it is not the gate.

Run them:

python analysis/verify_claims.py      # recomputes every published number
python analysis/verify_refactor.py --ref runs/board300 --new runs/<rerun>
python analysis/verify_determinism.py --runs runs/<cpu1>,runs/<cpu2>,runs/<cpu4>

harness/push_hf.py refuses to upload unless all three artifacts say pass: true. That is the mechanism, not a promise: the gate reads the JSON, not our assertion, and it blocked this release until the determinism defect was fixed.

Data

The three upstream datasets are not redistributed here — each carries its own terms. Obtain them from the original sources and build locally:

domain	source	accession
antibiotic	CO-ADD open screening data	`co-add.org`
regulatory DNA	Sample et al., 5′UTR MPRA	GEO GSE114002
antibody	MIT-LL / AAlphaBio AlphaSeq binding	public AlphaSeq release

harness/ holds the automated lab and the builders; analysis/ holds the supply and verification scripts.

The automated lab

The lab is a replay, not a simulator. harness/lab_replay.py serves only measurements that exist in the historical wetlab tables: an action with no historical measurement returns unsupported_action, costs nothing and is counted as an invalid request. It is never filled in by a surrogate model, so no number an agent sees was invented by this code.

module	what it does
`run_campaign.py`	entry point; pins threads before numpy, asserts the pools, writes run provenance
`campaign.py`	round controller and campaign state; nomination and confirmation
`lab_replay.py`	the lab: historical measurements, visibility tiers, cost accounting
`policies.py`	acquisition — ranking and batch selection
`methods.py`	the method search over released labels (grouped-CV recipe choice)
`memory.py`	cross-task memory; warm-start recipe recommendation
`evaluator.py`	independent scoring against the frozen success spec
`contracts.py`	request / objective / result schemas
`goals.py`, `llm_goal.py`	scripted and model-driven goal policies
`llm_client.py`	model transport; reads endpoints and keys from a gitignored secrets file at run time, nothing baked in
`ledger.py`	discovery and confirmation budget ledger
`determinism.py`	thread pinning and score quantization (spec §6.3)
`domains.py`	the per-domain task schema: assays, thresholds, which clauses are real

Builders (p0_extract_coadd.py → build_campaign.py → build_pool.py → make_instances.py) go from raw public data to campaign tables to instances. validate.py, aggregate.py, report.py and rescore.py check and summarise runs; contamination_probe*.py test for leakage.

What is not here: the raw datasets (not ours to redistribute — see Data below), the built campaign tables and instance sets (not built yet for v0.2), and the v0.1 run outputs. The code is Python 3.12 with numpy 2.5, pandas 3.1, scikit-learn 1.9, scipy 1.18 and threadpoolctl 3.7; threadpoolctl is not optional, since determinism.py uses it to verify the thread pools rather than trust the environment.

Two things the push tool refuses, so the repo cannot contradict itself: shipping a verification script without the modules it inspects, and shipping a result without the script that produced it. The first exists because the first push of this package did exactly that — verify_claims.py went up without the four modules its wiring guard reads, so nobody who downloaded it could run the verifier or check the spec's claims about those modules.

Status

Design package, pre-release. The instance sets are not built yet: the C7 loop-necessity screen must run first, and the released problem count will be what survives it rather than a round number chosen in advance.

Outstanding, in the order it has to happen:

Build the per-domain instance generators for DNA and antibody.
Run the C7 loop-necessity screen per instance and discard what fails it.
Re-run the remaining 93% of the board under the spec §6.3 determinism fix. The 7% tested reproduces the released values exactly, which is evidence, not coverage.
Implement the graded discovery-curve AUC in the scoring path; the loop_gain definition in Scoring above is specified, not yet implemented.

Verified and settled: the three-domain rule shape, the measured supply and allocation, the three v0.1 defects and the determinism fix, each with a gate artifact in results/ that harness/push_hf.py reads before it will upload.

Citation

Unpublished. Please do not cite as a finished benchmark; the C7 screen has not been run and the released instance count is therefore not yet determined.

Downloads last month: 17

Total file size:

543 kB