acceptodds
Under review as a conference paper at ICLR 2027

Learning What to Check: Process Supervision with Artifact-Grounded Verification for Scientific Agents

Abstract

Language-model agents can search the literature, write analysis code, and operate scientific software. A prerequisite for improving such agents from experience is scalable feedback. Coding provides an instructive contrast: compilers and tests score attempts automatically and localize failures. In experimental science, decisive labels often arrive only after costly wet-lab work and reveal little about which intermediate decision failed. We ask whether the structured artifacts produced during scientific work can provide an analogous source of feedback. We focus on one capability within the broader scientific process: checking computational outputs before they guide experiments. Scientific pipelines often encode the same underlying quantities in multiple files, creating consistency relations that can be recomputed without access to experimental outcomes. We formalize review as three abilities (selecting what to check, executing the check, and interpreting its result) and construct a benchmark in which the relevant checks and their programmatic semantics are controlled. The resulting diagnosis is a check-elicitation gap: the agents we evaluate can execute a specified check but often fail to identify which check is relevant. This diagnosis motivates a model–verifier architecture. The model handles open-ended check selection and computation; missing check knowledge can be supplied at run time or distilled into its weights. An independent verification layer then recomputes claims governed by exact programmatic rules, without consulting task labels. Model-side interventions raise performance on withheld defects from 12.8% to above 88%, while verification restores accuracy on defect-free inputs to 91.7% without sacrificing those gains. The missing-check pattern also appears on an external biological protocol benchmark. More broadly, our results suggest a division of labor for artifact-producing scientific workflows: train flexible selection and computation into the model, and place machine-checkable claims behind an independent verification boundary.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
LLM agents, scientific agents, process supervision, post-training, tool use, agentic evaluation, verifiable rewards

Reviews

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

This paper studies how scientific agents inspect computational outputs, separating check selection, execution, and interpretation. Using a controlled benchmark of simulated neoantigen-selection outputs, the authors find that models can execute specified checks but often fail to propose relevant ones. Tool-triggered retrieval and context distillation improve detection of withheld defects, while increasing false alarms on clean inputs. An independent deterministic verifier then recomputes claimed findings from the underlying files and substantially reduces these false alarms.

Critical strengths

The distinction between check selection, execution, and interpretation provides a useful way to diagnose agent failures. Reporting performance on clean inputs exposes the false alarms introduced by retrieval and distillation. The replication across two serving configurations is also useful.

Critical weaknesses
  1. The motivation is insufficiently focused. The paper begins with scalable feedback for scientific self-improvement, but studies consistency checks on completed files. It does not clearly explain why this task requires the proposed architecture rather than conventional pipeline validation.

  2. The narrative lacks a clear central contribution. The abstract and main text move between benchmark construction, retrieval, distillation, verification, and serving sensitivity. Their relationship is difficult to follow, leaving the paper closer to a collection of experiments than a coherent methodological argument.

  3. The benchmark makes the central problem somewhat artificial. All 17 checks are predefined, and a short deterministic program solves the task when given the complete rules. Withholding selected rules demonstrates a knowledge-access gap, but provides limited evidence of open-ended scientific check selection.

  4. The main failure mode is substantially driven by an underspecified rule. Most false alarms concern the purity check, whose statistic and tolerance are omitted from the teacher prompt. Simply supplying the full definition largely resolves the problem, weakening the case that the observed failures require the broader framework.

  5. The validation is too narrow for the broader claims. The main experiments concern one simulated workflow, with only 42 clean test bundles. Coverage is self-reported, and the external experiments do not establish transfer of the complete framework to other scientific workflows.

  6. The presentation needs substantial revision. The figures are sparse and visually underdeveloped, offering little help in understanding the architecture or experimental logic. Repeated explanations and numerous implementation details further obscure the main message.

Questions for authors

see Weaknesses

2 comments

Thank you for the review. You are right that the motivation was not focused and the central contribution was hard to find. That is our failure of presentation. The general response restates the paper in plain terms. Here we answer your points in order, in the same plain terms; the exact numbers and intervals are in the revised PDF (blue text).

W1. Why is conventional pipeline validation not enough?

Conventional validation is a fixed set of checks that a person writes in advance. It works well for problems someone has already thought of, and our verifier is exactly this kind of validation. The paper asks a different question: when an agent reviews a pipeline output, who decides which checks this output needs? For a new pipeline, or a new kind of error, nobody has written that list yet.

Our results show that both parts are needed:

  • Validation alone cannot find a problem nobody chose to check. Applied to the base model's answers, the verifier leaves its accuracy unchanged (12.8% before and after).
  • The model can choose the right checks once it is asked to look broadly, or trained to.
  • But when it looks broadly, it starts calling correct outputs wrong. Here validation helps: rechecking each claim removes almost all of these false alarms.

So the model supplies the choice, and validation supplies the reliability. §1 now makes this argument ("Why validation alone is not enough").

W2, W6. The central contribution is unclear and the paper is hard to follow.

We agree, and thank you for saying it plainly. The revision is organised around one message: the hard part for an agent is choosing what to check, not running the check; when it checks more broadly it makes errors in interpreting the results; verifying its claims fixes those errors but cannot do the choosing for it. Concretely:

  • §2 opens with a short formal definition of the problem.
  • Each section starts by saying which part of the message it tests.
  • Design history moved to the appendix.
  • Figure 2 now shows the measured rate for each of the three abilities.

We will keep improving the writing.

W3. The benchmark makes check selection artificial.

Partly yes, on purpose. To measure whether an agent chooses the right checks, we need to know the right answer for every possible check, and only a controlled benchmark gives that. The revision states that we do not claim open-ended scientific check selection.

Your concern also has a stronger form: perhaps the model knew the checks and simply was not asked. We tested this with new prompts that name no hidden check and only say that the list is incomplete. You were partly right: such a prompt recovers most of the gap, so we now call it a gap in eliciting checks rather than missing knowledge. Training still adds about 10 points on top of the best prompt, and the difference is significant (§3, Table 1).

W4. The false alarms come almost entirely from one underspecified rule (purity).

Agreed, and this turned out to be central. The new prompts make the same mistake on the same rule, with no training involved. So it is a natural trap for any agent that checks broadly, not a side effect of our method.

One paragraph defining the rule removes these false alarms (§6). But we could write that paragraph only after we had found the rule by studying test failures. The verifier was fixed before that analysis, and it removed the same false alarms without anyone pointing to the rule. A real pipeline has many such rules, and nobody knows in advance which ones will cause trouble. That is the case for verification.

W5. The validation is narrow, and coverage is self-reported.

  • Why the method is not narrow. It needs only files that record the same quantity in more than one place (counts and fractions, identifiers and joins, rankings, totals), which most computational pipelines have. A verifier for such relations is written once per pipeline, like a unit test. Our evidence comes from one benchmark, and the limitations section says so.
  • Clean outputs. The false-alarm result now rests on a sealed set of 228 new clean cases, not only the original 42.
  • Self-reported coverage. We checked the claims, not only counted them. Where the verifier recomputes a claimed check, the answer key almost always agrees. The failures it found were correct numbers with wrong conclusions, never invented numbers. This still does not prove that the computation came before the claim, and the revision says so.
  • External benchmarks show the same failure pattern. We no longer present them as evidence that the method transfers.

Thank you again for the careful review.

Thank you for the response. I have read it carefully, but my concerns remain. The figures, the core idea, and the overall presentation are still far below the standard for acceptance, and the authors have not provided further empirical work to address the specific weaknesses I raised. The response explains and reframes rather than demonstrates. I am not persuaded, so I am keeping my rating and confidence unchanged.

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

The paper asks whether redundant artifacts from a scientific pipeline can supply intermediate feedback when outcome labels are unavailable. It builds simulated neoantigen-calling bundles governed by 17 programmatically decidable cross-file invariants, 7 named in the prompt and 10 withheld, with at most one planted defect. The diagnosis (Fig. 1a) is a check-elicitation gap: 100% when the relevant check is named, 12.8% when withheld, and 98.8% when all 17 are printed with weights frozen. Two Stage 1 interventions supply withheld checks without listing them: a tool-triggered knowledge layer (12.8 to 88.1% withheld, clean 98.8 to 41.7%) and self-distillation of a LoRA adapter from all-checks teacher trajectories (12.8 to 92.2%, clean 67.9%). Section 6 traces the false alarms to one underspecified check definition and confirms it prospectively on 228 sealed clean bundles (55.1% to 0.9%). Stage 2 adds a deterministic claim verifier covering 15 of 17 invariants, raising clean accuracy to 91.7/96.4% as a tool and 100% as a gate.

Critical strengths
  1. A programmatically gradable benchmark that separates check selection from execution, with honest measurement. The named-vs-withheld contrast (100.0 vs 12.8%) and the weight-frozen print-all control on the same 152 dev instances (17.1 to 98.8%) cleanly show that proposal, not execution, is the bottleneck. Every stratum is reported separately, differences are paired with bootstrap CIs, a clean split was sealed before the Section 6 test, and scoring defects are disclosed. No existing benchmark lets the check space be selectively withheld this way.
  2. The coverage-vs-selectivity finding with a mechanistic diagnosis. Both interventions reach ~90% withheld recall while sharply raising false alarms, and 40 of 44 false alarms trace to one invariant transferred by name without its definition, confirmed prospectively by adding one paragraph. "Report false-alarm rate beside every coverage gain" is a concrete and verifiable lesson.
Critical weaknesses
  1. No control distinguishes a knowledge gap from a prompting gap. Every baseline is the base model under the fixed 7-check prompt. There is no arm that tells the model to enumerate and run every cross-file invariant it can derive without naming any, no self-refine or best-of-N at a budget matched to the knowledge layer's extra 1,351 characters per rollout, and no arm applying the verifier to the base model. The withheld checks are simple (sum-to-1e6, ranks 1..N, af = ad_alt/(ad_ref+ad_alt)), so an exhaustiveness prompt might propose many of them. The only outcome-driven comparison (RAFT, GSPO) is on an earlier nine-defect task with 20 instances and p=1.0. Without these, the 12.8 to 88/92 gap cannot be attributed to supplying the check space rather than eliciting it.
  2. The verifier result is close to circular. The paper notes that running all 17 checks is the reference solver at 100%, and the distilled student already claims all ten withheld checks in 97%+ of rollouts. A verifier that re-derives each claimed check with exact programmatic semantics therefore reconstitutes the reference solver, making the 100% mandatory-gate result near-tautological. The optional-tool number on the first stack is not prospective (the purity false alarms were known when the registry was frozen), and the prospective second-stack result starts from a 47.6% clean baseline the authors attribute to a serving artifact. The verifier is not a training signal, so "process supervision" is only partly delivered; what is delivered is 15 hand-coded checks whose transfer to a new pipeline means writing a new registry.
  3. Statistical fragility. Clean-stratum effects rest on 42 bundles at k=2 with CIs spanning 25 points. Serving configuration alone moves clean accuracy 67.9 to 42.9%, as large as the difference the paper interprets between its two methods. One training run per stack, no seed variation. Only 2 of 10 withheld kinds are held out from distillation, and their names appear in teacher final answers, so transfer to unmentioned checks is untested. BioProBench shows no harm (+2.2, CI [−0.7, +5.2]); BixBench has n=20.
Questions for authors
  1. A prompting-only control on the 160 withheld-defect instances: base model told to enumerate and execute every cross-file relation it can derive, same turn budget, plus best-of-N at matched tokens. How much of the gap closes, and at what clean accuracy?
  2. Clean accuracy and withheld score of the base model given the verifier as a tool and as a gate?
  3. How is the mandatory gate implemented on rejection? Does the agent get another turn, and is 100% reached by the agent or by the gate overriding it?
  4. For the 25-point swing between serving configurations, was decoding, chat template or NVFP4 vs BF16 varied one at a time? Which abstract numbers change under the other configuration?
  5. Per-seed variance for at least the first-stack distillation, and a k=1 vs k=2 breakdown.
4 comments

Thank you for a precise and very helpful review. Your questions named exactly the controls the paper was missing. We ran them, and they made the study more complete. Changes in the revised PDF are in blue.

W1/Q1. You asked whether the gap is a knowledge gap or a prompting gap, and suggested a prompting-only control.

This was an excellent question, and the answer changed how we describe the result. On your 160 withheld-defect instances and the 42 clean bundles (base model, k=2k=2, one serving process):

armwithheld defectscleanclean, with verifier
base, 7 named checks9.498.298.8
+ "the checklist is not complete; derive and test every relation"82.713.198.8
no checklist, "check consistency"67.34.898.8
distilled model92.746.498.8

Without the verifier, the distilled model's clean accuracy is the least stable number we report (46.4 here; 67.9 and 47.6 in the paper's two stacks, see Q4). With the verifier it is above 91% in every case.

  • You were largely right. The instruction recovers 73.3 of the 83.3 points, and even the open instruction with no checklist reaches 67.3. We no longer call this a knowledge gap; the revision calls it a gap in eliciting the checks.
  • Training still adds +10.0 [+6.2, +13.8]. The distilled model claims all ten withheld checks in 99% of rollouts; with the instruction it is 65%. The distilled model also names the right defect more often.
  • The instruction reproduces our interpretation finding without any training. Checking broadly drops clean accuracy to 13.1%, mostly through the same purity rule. The verifier removes these false alarms. So the trade-off between selection and interpretation is not an artifact of distillation.

On best-of-N at matched budget: the base model's best-of-2 already doubles the tokens and reaches 21.9% on withheld defects. We also agree that the RAFT/GSPO runs (Appendix A) are motivation, not evidence, and the text now says so.

W2/Q2/Q3. You asked whether the verifier is circular (close to the reference solver), how the gate works, and how the verifier does on the base model.

You are right about the gate, and we corrected the text.

  • Q3, how the gate works. It is a post-hoc re-score of the finished answer; the agent gets no extra turn. If the verifier's recomputation does not support a claimed defect, the answer falls back to CONTINUE. It never turns CONTINUE into BLOCK. So its 100% on clean bundles holds by construction for registered checks, and we now report it only as a consistency property.

  • Q2, the verifier on the base model. Two measurements:

    • As a gate on the paper's base-model test rollouts: withheld defects 12.8 → 12.8; clean 98.8 → 100; named 100 → 100. The 13 rollouts it changed were all already wrong. The reference solver scores 100%. The verifier adds nothing when the agent does not propose the check, because it cannot create recall.
    • As a tool the base model can call (budget 4): clean 100.0 (paired +1.8 [+0.0, +4.8]); withheld defects 12.3 vs 9.4 (+3.0 [−1.6, +7.3], not significant).

    In the tool arm the agent itself decides. In all 83 rejections in the paper's runs, the model abandoned the claim, and in 74 it then named the correct defect.

On transfer: a new pipeline does need new verifiers. We see this as a reasonable division of labour. Verifiers are written once per pipeline, like tests; the choice of what to check has to come from the model.

W3/Q5. You asked about statistical robustness: the small clean set, the lack of seeds, and the kk split.

  • Clean set. The sealed clean split is complete: 228 new bundles, k=1k=1. False-alarm rates:

    • base 2.6%;
    • distilled 55.7%;
    • distilled with a one-paragraph definition 0.9% (paired −54.8 [−61.4, −48.2]);
    • retrained with the definition 24.1% (−31.6 [−39.9, −23.2]).

    This now carries the false-alarm result instead of the 42 bundles.

  • Seeds. We could not repeat training in the discussion window (one run takes 21 h on the GPU that served the controls), and the limitations section says so. For sampling variance, a k=8k=8 run of the distilled model on 40 withheld instances gives a 1.6-point s.d. for a k=2k=2 estimate.

  • kk split (first vs second rollout, paired):

armstratumk0k_0k1k_1k1−k0k_1-k_0 [95% CI]
basewithheld12.812.8+0.0 [−6.6, +6.6]
distilledwithheld92.292.2+0.0 [−3.8, +3.4]
distilled + verifier toolwithheld94.795.6+0.9 [−1.6, +3.4]
distilledclean (42)69.066.7−2.4 [−21.4, +16.7]

Single-rollout clean estimates on 42 bundles vary by about ±15 points. That is why we now lead with the 228-bundle split. The full table is in the appendix.

  • Held-out kinds. Thank you for raising this; checking it led to a correction. All 17 defect identifiers appear in every prompt's answer format, including the base model's. The held-out kinds therefore test transfer without a worked example, not invention of an unseen name.

Q4. You asked what causes the 25-point swing between the two serving stacks.

The factors were not varied one at a time, and we say so. Re-checking the launch files, we also found a difference the paper omitted: the server's reasoning and tool-call parsers differed between the two stacks. A one-factor test that changes only the parsers is running; we will post its result here if it finishes before the discussion closes, and it will be in the appendix. Under the other stack, the headline numbers barely move (withheld 12.8 → 92.2 becomes 13.3 → 91.9). Only the distilled model's clean accuracy without the verifier changes materially (67.9 vs 47.6), and the verifier brings both above 91%.

Thank you again. Your review improved the paper substantially.

Thanks the author for addressing my problem partially. I maintain my score thereby.

AuthorsOpenReview ↗

Follow-up on Q4: the parser test is done.

Reminder of the question. We trained and served the distilled model twice, in two different setups ("stacks"; §5, "Replication in a second training-and-serving stack"). Most results agree across the two. One number does not: accuracy on clean bundles (pipeline outputs with no defect, where the right answer is "no problem") without the verifier. It is 67.9% in the first stack and 47.6% in the second. A low number here means false alarms: the model calls correct outputs wrong. You asked what causes this 20-point gap. Many things changed between the stacks at once:

first stacksecond stack
training GPU1× RTX PRO 6000 (96 GB)4× H200 (141 GB), data-parallel
base weights in trainingBF16 loaded in 4-bit NF4 (QLoRA)BF16
max sequence length32,76849,152
steps / time846 / 20.8 h910 / 5.8 h
servingNVFP4 checkpoint, vLLM 0.28.0, same GPUBF16 checkpoint, vLLM 0.27.1, H200
server parserstool calls qwen3_xml, no reasoning parsertool calls qwen3_coder, reasoning qwen3
clean accuracy, no verifier67.947.6

Both use the same 573 training trajectories and the same LoRA settings (r=16r=16, 2 epochs). The last parser row is the difference the paper did not mention, so we tested it on its own.

The test. On the first stack (NVFP4, RTX PRO 6000, vLLM 0.28.0, first-stack model), we re-ran the 42 clean bundles twice, changing only the parsers from the first stack's to the second stack's. Model, data, prompts and everything else stayed the same.

The result.

  • Distilled model: 46.4% with either parser setting (paired difference +0.0, 95% CI [−11.9, +13.1]).
  • Base model: 98.2% vs 97.6%, also no real change. The base model rarely raises false alarms because it checks little.

What this means. If the parsers caused the gap, switching them should move the score by about 20 points. It moved by zero, and the interval rules out a change that large. So the parsers are not the cause. The gap must come from the other factors, or from noise: with only 42 bundles, this number varies by about ±15 points between single runs. That is why the revision rests the false-alarm result on the 228-bundle sealed split instead.

What does not change. With the verifier, clean accuracy is above 91% in both stacks, so the paper's conclusion holds either way. We will add this test to the appendix.

Reviewer_x4GjOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper studies whether LLM agents can review computational biology pipeline outputs. It introduces a synthetic benchmark that withholds some consistency checks, and argues that agents execute named checks but fail to propose withheld ones. It addresses this with retrieval, self-distillation and a deterministic claim verifier. The manuscript reads more as a sequence of experiments than a paper with a unified, formally defined method.

Critical strengths
  1. The evaluation is careful. It uses held-out splits and paired confidence intervals, and it reports negative results openly.
  2. The paper documents the development process in detail, from the initial diagnosis through each round of improvement.
  3. The experiments are extensive, including a replication in a second training and serving stack, even it is with the same model and benchmark.
Critical weaknesses
  1. The paper reads as an experiment log rather than a paper. There is no formal problem definition or method. The main text is filled with design iteration and infrastructure details, and I do not understand why the authors report so many intermediate results, without a given central finding. As a result, the reader will easily get lost.
  2. There is no evidence of generality, and the claims overreach. Everything rests on one self-built synthetic benchmark with single injected defects and no borderline cases. “Learning what to check” and “process supervision” are not supported: training is SFT on key-filtered turns, and the verifier is never used as a training signal.
  3. The scope is narrow. All main results come from one self-synthesized benchmark and one primary model, which limits how far the conclusions generalize.
  4. The writing needs substantial work. Several paragraphs list results without explaining how they connect to each other or to the paper’s main argument.
Questions for authors

I encourage the authors to reorganize the manuscript around a clear problem and method rather than presenting it as an experimental log. The two questions below may help guide that revision. Q1. What is the single central contribution, and could the paper be restructured around it, with a formal problem definition and a method section? Q2. How does the model perform when no checks are named and the prompt contains only a generic instruction to check consistency?

2 comments

Thank you for the review and for the two guiding questions. They shaped the revision directly. Your second question in particular led to the most useful new experiment (Q2 below). You are right that the submission did not state its central contribution clearly. That is our failure of presentation, and the general response now restates the paper in plain terms. Changes in the revised PDF are in blue.

Q1 (with W1, W4). You asked: what is the single central contribution, and what is the method beyond iterative fixes?

The central claim, in one sentence: when an agent reviews computational artifacts, choosing which checks to run is the bottleneck, not running them; broadening that choice creates errors in interpreting the results; verifying the checks the agent claims repairs interpretation but cannot replace the choice.

The revision is organised around this sentence:

  • §2 now opens with a formal problem definition. A bundle comes with a set of decidable checks CC. The prompt names some (NN) and withholds the rest (WW). We measure three rates separately:
    • selection: does the agent claim the violated check?
    • execution: is a claimed check computed correctly?
    • interpretation: given correct findings, does the agent name the right defect?
  • §4–7 give the method. Stage 1 raises selection, by instruction, retrieval or distillation. Stage 2 is a verifier that accepts or rejects only the checks the agent claims. Its recall is therefore bounded by the selection rate. We confirm this: on the base model it leaves withheld-defect accuracy at 12.8%.
  • Each results section opens with the part of the claim it tests. Design notes moved to the appendix.

Q2. You asked: would a generic instruction, naming no checks, do as well?

Thank you. This was the right question. We ran it two ways on the same 160 withheld-defect and 42 clean test bundles:

armwithheld defectsclean
base, 7 named checks9.498.2
+ "the checklist is not complete; derive and test every relation"82.713.1
no checklist, "check whether these artifacts are consistent"67.34.8
distilled model92.746.4

The instruction recovers most of the gap (+73.3 points), so we no longer call it a knowledge gap. Training still adds a significant +10.0 [+6.2, +13.8]. The instruction also makes the model flag almost every clean bundle. This is the same interpretation failure the paper reports after training, and the verifier removes it (clean 98.8%). So the prompt arm supports the claim above from an independent direction.

W2. You noted that "learning what to check" and "process supervision" overreach, and that the setting has single defects with no borderline cases.

We agree on "process supervision". The verifier acts only at run time, so we removed the term and retitled the paper Learning What to Check: Check Elicitation and Artifact-Grounded Verification for Scientific Agents. "Learning what to check" we keep in a narrow, measured sense: after distillation the model claims all ten withheld checks in 99% of rollouts (10% before), and on the two kinds with no training instance it gains +68.9 [+57.3, +79.9].

Single defects are a deliberate design choice: they let us attribute each failure to selection, execution or interpretation. The one borderline case we studied, the purity rule, is exactly where the trained model and the prompted model both fail. It is also where the verifier helps most.

W3. You noted the narrow scope: one benchmark and one main model.

We agree that our evidence comes from one benchmark, and the limitations section says so. The method itself is not tied to it. It needs only files that record the same quantity in more than one place (counts and fractions, identifiers and joins, rankings, totals), which many computational pipelines have. A verifier for such relations is written once per pipeline, like a unit test. We used one controlled benchmark because measuring which checks an agent chooses needs ground truth for every possible check. The revision adds no new domain. Instead it adds controls that make this one result harder to explain away:

  • the prompting arms;
  • the verifier on the base model;
  • the completed 228-bundle sealed clean split.

BioProBench and BixBench appear only as consistency checks, not as evidence of transfer.

Thank you again for the review.

Thank the authors for the response. However, the revision does not significantly improve the paper's quality to a publishable level. I will retain my score.

Comments on the paper

1 comment

We thank all three reviewers for careful and constructive reviews. Two reviewers found the motivation unfocused, the central contribution unclear, and the validation narrow for the claims. We agree that the submission did not explain these well. This is a failure of presentation on our part. The revision (blue text) starts to fix it, and we will keep improving it. Here we restate the paper in plain terms; the per-reviewer replies give the details of the new experiments.

The problem. AI agents now run computational biology pipelines, and the outputs decide which candidates go on to costly wet-lab experiments. Someone has to check those outputs first. An expert asks what should be true across the files (read counts should match the reported allele fractions; every ranked candidate should trace back to a real mutation) and then tests it. We ask whether an agent can do this without being told which checks to run. This also matters for agents meant to improve from experience: they need fast, automatic feedback, and the real outcome, a wet-lab result, is slow and expensive.

What we found. An agent runs any check it is told about almost perfectly (100%), but rarely thinks of checks it is not told about (about 10%). The bottleneck is choosing what to check, not running the check. Pushing the agent to check more broadly fixes this but creates a new error: it starts flagging correct outputs.

What we contribute.

  1. A way to measure the bottleneck. A benchmark in which a program can decide every check and we control which checks the prompt names. It measures choosing, running and interpreting a check separately.
  2. A method that works. The model is trained (or prompted) to choose checks broadly, and an independent verifier recomputes each claimed check from the files alone. Accuracy on defects the prompt did not name rises from 12.8% to 92%, and the verifier brings accuracy on correct outputs back to 92–99%.
  3. A design rule. Leave the open-ended choice of checks to the model, and put claims a program can decide behind a verifier. Neither half works alone.

Why it is not narrow. The method needs only what many pipelines already have: files that record the same quantity in more than one place (counts and fractions, identifiers and joins, rankings, totals). A verifier for such relations is written once per pipeline, like a unit test. We use one controlled benchmark because measuring choice needs ground truth for every possible check. The same failure profile also appears on BioProBench, which we did not build. We have narrowed the wording of our claims to match this evidence.

Why the positive result matters. It was hard to obtain. Outcome-reward training (RAFT, GSPO) gave no reliable gain. Teacher trajectories built from the known answer were contaminated. Our first knowledge layer closed only part of the gap. The final result holds on a held-out test split, under a second training and serving setup, and against the new controls below.

New in the revision (details in the replies)

  • A prompt alone closes most of the gap (9.4 → 82.7), so we now call it a gap in eliciting checks. Training still adds +10.0 [+6.2, +13.8]. The prompts also cause the same false alarms, and the verifier removes them (x4Gj Q2, Z1JS W1).
  • The verifier cannot replace the model's choice: on the base model it leaves accuracy at 12.8% (Z1JS W2, Unm2 W1).
  • The sealed clean split is complete (228 new bundles) and confirms the false-alarm finding (Z1JS W3, Unm2 W4).
  • Two corrections: all 17 defect names appear in every prompt, so "withheld" means the check's description is withheld (Z1JS W3); and we removed "process supervision" from the title (x4Gj W2).

The changes are in blue in the PDF (mainly §1–3, §6–7 and Appendix H). Their records and scripts are in the updated supplementary material (folder revision/).

Thank you again. We are glad to answer any follow-up questions.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.