acceptodds
Under review as a conference paper at ICLR 2027

MedGauge: Evidence-Grounded Commit Protocols for Reliable Tool-Using LLM Agents in Medical Measurement

Abstract

Language-model agents increasingly operate the pipelines that turn medical images into reported measurements such as ventricular volume and cardiothoracic ratio. When such a pipeline errs, its output stays well formed and physiologically plausible, and an agent given quality signals still explains them away in favour of the value it holds. Runtime enforcement moves the decision to a program that blocks a violating action or substitutes a predefined one, but neither response states what evidence would make a blocked measurement reportable. We present MedGauge, a small commit layer that decides which values may be signed as trusted and which action would make a rejected value acceptable. Its observation channels compute evidence without executing the stage they audit, and sources that share an origin count as one witness. Each alarm names the call that clears it, which turns a blocked report into a repair the agent can execute, and a commit protocol accepts a report only when preconditions checked on the tool-call record hold. On a benchmark of 1,068 cases spanning cardiac MRI, abdominal CT and chest radiography, MedGauge signs no wrong value across the 812 covered fault-and-reasoner combinations of its two primary reasoners, and across four reasoners it releases none of 416 conflicts that the available evidence cannot resolve. It also achieves the highest usable output of any compared agent on every task (56% to 66%), because declared discharge conditions let the agent clear false alarms and repair faulty cases. On abdominal CT, repairs rise from 3 cases to 62. With channels, alarms and discharge conditions fixed, removing only the commit check produces 30 silent commits and 107 released conflicts. One adapter per task extends the layer from volumes to a two-dimensional ratio, and we release the code and the benchmark construction.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
tool-using LLM agents, agent safety, reliability, trustworthy AI, AI for healthcare

Reviews

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

This work presents MedGauge, a small commit layer that decides which LLM agent values may be signed as trusted and which action would make a rejected value acceptable. The results show that MedGauge improved performance of language-model agents on a benchmark of 1,068 cases spanning cardiac MRI, abdominal CT and chest radiography.

Critical strengths

An important problem with a practical solution.

Critical weaknesses

(1) Difficult to follow as it lacks details for clinical concepts (2) This study does not cite some relevant work, making it hard to assess the innovations and contributions, including ShieldAgent, FormalJudge, and RvLLM.

Questions for authors

can you compare MedGauge with a deterministic controller? does MedGauge reverse naturally occurred failures?

1 comment
AuthorsOpenReview ↗

Response to Reviewer pmtY

Thank you for reviewing our paper and for finding the solution practical. To make the paper accessible to readers outside medical imaging, we added clinical background and a step-by-step example, discussed the three related works you pointed out, and ran new experiments for both of your questions.

"Difficult to follow as it lacks details for clinical concepts"

We added Appendix A0 specifically for readers without a clinical background. This section explains the clinical quantities we measure, including heart chamber volumes, abdominal organ volumes and the heart-to-chest width ratio, where pixel-to-millimetre scaling comes from, and why a scaling error produces a wrong number that still looks physiologically normal. It concludes with a glossary of all key terms, and Table A1 collects the mathematical notation.

In the main text, Section 3.1 now walks through one CT case from start to finish: a calculation fault reports a liver volume that is too low, an independent check flags the liver, the agent recomputes the volume, and MedGauge signs the corrected value once the flag is cleared. Section 3 also defines terms such as handles inline where they first appear.

"does not cite some relevant work, making it hard to assess the innovations and contributions, including ShieldAgent, FormalJudge, and RvLLM"

Section 2 and Appendix N now cite and compare all three.

WorkWhat it checks
ShieldAgent, ICML 2025An agent's action trajectory against probabilistic rule circuits extracted from policy documents
FormalJudge, ICML 2026Agent behaviour against Dafny specifications compiled by a model and verified with an SMT solver
RvLLM, 2025Model outputs against domain-expert constraints written in a formal specification language

All three verify whether an agent trajectory or model output satisfies a written specification. MedGauge addresses a different problem: deciding which continuous measurements from a tool pipeline may be reported as trusted. Its checks compute evidence without running the pipeline step under audit, and each alarm names the exact tool call that clears it. This executable repair path is what turns a blocked measurement into a recovered one.

"can you compare MedGauge with a deterministic controller?"

Yes. Table 1 now includes a deterministic rule controller that runs every check without a language model and withholds a value whenever a blocking alarm fires.

The comparison shows what a fixed rule can and cannot do. The controller reaches high safety by withholding every flagged value, with zero silent errors (wrong values signed as trusted) on cardiac MRI and abdominal CT. Because it never investigates, however, it repairs zero faults and needlessly withholds at least half of the correct cases where a check fires. MedGauge is at least as safe on every task, yet its reasoning agent follows each alarm's repair instructions to fix faulty measurements and clear false alarms, raising usable output (cases signed as trusted with correct values) by 24 to 31 percentage points across the three tasks (Table 1). Putting a reasoning agent under a programmatic commit check thus preserves safety while recovering usable measurements.

"does MedGauge reverse naturally occurred failures?"

It keeps them from being reported as trusted, and it repairs those that a parameter can fix. For any natural pipeline error inside its coverage, MedGauge prevents a plausible-looking wrong number from being signed as trusted and routes it to human review. Tested against expert annotations on abdominal CT, MedGauge signs none of the covered natural errors under any tested language model, including severe failures where an organ is measured at a tiny fraction of its true volume (Section 4.2, Appendix M.2). The same checks without our contract do not achieve this: a ReAct agent driven by a weaker model still signs most of the covered errors on the main benchmark.

Repair applies when an error comes from a recoverable parameter such as a wrong slice thickness or unit scale: the alarm names the corrective call, and the agent runs it to restore the correct value. On injected CT faults, where the true value is known, MedGauge repairs nearly half (Table 1). When a natural error comes from two segmentation masks disagreeing on an organ's boundary, no parameter change can tell which mask is right, so MedGauge flags the value for review without guessing.

Thank you again for your helpful feedback. We hope these revisions make both the clinical context and the contributions easy to follow.

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

MedGauge introduces an evidence-grounded commit protocol that separates medical measurement reasoning from the authority to approve and report results. It evaluates 1,068 cases across cardiac MRI, abdominal CT**,** and chest radiography using four models: Qwen3.8-Flash, DeepSeek-V4-Flash, Llama 3.3 70B**,** and GPT-4o mini. The protocol prevents incorrect commits across 812 covered fault-and-reasoner combinations for its two primary models, while improving usable output through actionable repair conditions.

I find the separation of reasoning and commit authority a strong contribution, particularly when agents may explain away measurement errors despite available evidence. The repair mechanism is also useful compared to simply blocking incorrect results. However, the safety guarantees depend heavily on the coverage of observation channels. In the natural CT evaluation, only 8 of 62 measurement errors fall within registered coverage, leaving many errors still undetected. While the approach is technically sound within its defined scope, there is still a question about how this can provide broader clinical safety. Overall, a useful contribution that supports a weak acceptance.

Critical strengths

the paper separates reasoning from commit authority which is a good design.

The experiments demonstrate improvements in both safety and usable output, which is important since simply rejecting every uncertain measurement is not practically useful.

Critical weaknesses

While the protocol is effective for covered errors, how to establish and maintain sufficient coverage for broader clinical applications remains unresolved.

Questions for authors

In the natural CT evaluation, 54 of the 62 measurement errors are outside the registered coverage, including 38 errors shared by both measurement paths. Have the authors considered using independently trained measurement models? How would that change results?

1 comment
AuthorsOpenReview ↗

Response to Reviewer DUim

Thank you for your positive assessment, and for recognising the separation of reasoning from commit authority and the value of repair over blocking. Both of your questions concern coverage, and we ran new experiments on each.

"how to establish and maintain sufficient coverage for broader clinical applications remains unresolved."

We agree that coverage determines how far the guarantee reaches in practice. The revision addresses this directly with a three-step procedure for a hospital to establish, extend and maintain coverage using its own labelled cases (Section 5). Applied to abdominal CT, this procedure nearly doubles the real errors inside coverage while MedGauge signs none of them under any reasoner, and removes about a quarter of all natural errors at the segmentation tool before any agent runs.

Establishing coverage. On CT, coverage is set by a threshold on how far the two segmentation paths may disagree. Using local annotated studies, a hospital selects the lowest threshold that keeps false alarms on correct values within a small budget. On our data, this calibration brings most large errors inside coverage, raises zero false alarms on the held-out main benchmark, and leaves safety on injected faults unchanged (Section 4.2, Appendix M.2).

Extending coverage at the tool. Most errors remaining outside coverage come from a systematic offset between the segmentation tool and the local annotation protocol. Because both paths share this offset, comparing them cannot detect it, but a hospital can remove it directly at the tool by fitting a per-organ scale factor on the same annotated studies (Appendix M.3).

Maintaining coverage. Whenever the scanner, acquisition protocol or segmentation tool changes, the hospital repeats both steps.

Coverage therefore does not rest on a fixed threshold chosen by the authors. A hospital measures and expands coverage on local data and recalibrates whenever its setup changes, and within that measured coverage the guarantee holds on real errors.

"Have the authors considered using independently trained measurement models? How would that change results?"

Yes. We tested an independently trained nnU-Net across all annotated CT studies: it slightly widens coverage with zero false alarms on the main benchmark, and shows that most shared errors come from the annotation protocol, not the model family (Appendix M.4).

We segmented all 300 annotated AMOS22 studies with an nnU-Net trained on BTCV, completely independent of TotalSegmentator's training data. Because BTCV is small, this model is accurate on typical cases but occasionally produces large outliers, so we use it to confirm the existing second path, raising an alarm when both paths differ from the primary one by more than 12% (the two-path check alone uses 15%). On the main benchmark, this raises coverage from 15 to 17 natural errors with no false alarms on correct values.

Why the gain is modest. Because both default paths use TotalSegmentator, a natural hypothesis is that they share errors because they share a model. Yet the independent nnU-Net errs in the same direction as TotalSegmentator on three quarters of the natural errors. When two independently trained models err together, the discrepancy reflects where the expert annotators draw the organ boundary, not a bias of one model family. Changing the model alone cannot eliminate this boundary offset, whereas the tool-level calibration above reduces it.

In short, an independent model modestly expands coverage where it fits local data, and cross-model agreement confirms that the remaining shared errors should be corrected at the tool.

Presentation. Thank you for noting where the paper required extra effort. We added Appendix A0 to explain the clinical quantities and key terms for readers outside medical imaging, added a step-by-step CT example and inline definitions in Section 3, and collected all notation in Table A1.

Thank you again for your constructive questions. We are happy to clarify anything further.

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

The paper presents MedGauge, a framework that prevents AI agents from reporting medical measurements as trusted unless they satisfy predefined evidence checks. It combines independent observation channels, actionable repair conditions, and a programmatic commit check. The paper evaluate it on cardiac MRI, abdominal CT, and chest radiography, showing fewer silent errors and more usable outputs than the compared baselines.

Critical strengths
  1. The paper tackles an important problem of AI agents in medicine. Giving an agent evidence of an error does not mean it will act on that evidence.

  2. The experiments are carefully structured. The ablations separate the effects of observation channels, repair instructions, and commit enforcement. The increase in repaired CT cases after adding discharge conditions is a convincing result.

Critical weaknesses
  1. Most experiments inject known errors and measure correctness against the original pipeline output. Particularly, Table A12 shows that 54 of 62 actual CT measurement errors identified using expert annotations fall outside the system's coverage.

  2. ToolGate and AgentSpec already support programmatic enforcement of execution constraints. MedGauge adds useful measurement-specific checks and repair conditions, but the paper does not directly compare against these frameworks with equivalent rules. It is unclear how much of the improvement requires the proposed framework rather than a conventional enforcement system with well-designed checks.

Questions for authors
  1. Can the authors provide a more complete evaluation of trusted but incorrect measurements on natural cases using expert annotations, including errors outside the predefined coverage?

  2. How would MedGauge compare with ToolGate or AgentSpec implementing the same measurement checks and repair conditions?

  3. In first sentence of abstract, "Language-model agents increasingly operate ..." sounds AI-patterned/generated.

  4. Figure 1, Figure 1a,b, and Appendix A in Introduction can be hyperlinked.

4 comments
AuthorsOpenReview ↗

Response to Reviewer aGTa (1/2)

Thank you very much for your thorough review, and for your positive feedback on the ablations and the CT repair result. We studied both of your questions carefully and ran new experiments to answer them. Evaluating real pipeline errors is important for a system of this kind, and the revised paper now reports this evaluation across all compared methods.

"Table A12 shows that 54 of 62 actual CT measurement errors ... fall outside the system's coverage." / "Can the authors provide a more complete evaluation of trusted but incorrect measurements on natural cases using expert annotations, including errors outside the predefined coverage?"

Yes. Table A13 now scores every method on the natural CT cases against the AMOS22 expert annotations, both inside and outside coverage. A reported value counts as wrong when it differs by more than 10% from the expert volume. Below we summarise the main findings, with full numbers in Section 4.2 and Appendix M.

Inside coverage, the guarantee holds on real errors. Across all 161 natural CT studies, MedGauge signs none of the 35 covered errors as trusted under any tested reasoner. These include the largest failures in the cohort, such as a kidney measured at 6 ml against 344 ml in the expert annotation. Having the observation channels alone does not guarantee this: under Llama-3.3-70B, ReAct + channels signs 10 of the 15 covered errors on the main benchmark because the model skips the check that raises the alarm, whereas MedGauge with the same model signs none (Appendix M.2). This confirms Proposition 1 on real pipeline errors.

The coverage in Table A12 came from an uncalibrated threshold, and local calibration roughly doubles it. On CT, coverage is governed by a single threshold on the disagreement between two segmentation paths, originally set on injected faults before any natural case was scored. In the revision, we calibrate this threshold on 200 separate annotated studies, selecting the lowest value that keeps false alarms on correct measurements within 1%. On the held-out natural cases of the main benchmark, coverage nearly doubles from 8 to 15 errors, captures 13 of the 19 errors above 25%, and raises zero false alarms on correct fields, while safety on injected faults is unchanged (Section 4.2, Appendix M.2). Any hospital can run the same calibration on local labelled cases to measure and expand its coverage.

The errors left outside coverage are mostly small boundary offsets, and all methods sign them at similar rates. Their median deviation from the expert volume is 14.5%, close to the 10% tolerance. Most of the missed tissue lies within a few millimetres of the organ border, reflecting a systematic difference between how TotalSegmentator and the AMOS22 annotators draw boundaries, and an independently trained nnU-Net errs in the same direction on most natural errors (Appendices M.3 and M.4). Because both segmentation paths share this boundary convention, path comparison cannot detect it, and MedGauge signs about as many of these errors as the baselines holding the same channels. The only exception is the LLM judge, which signs fewer by withholding over half of the correct values. Such a boundary offset belongs to the segmentation tool: a per-organ scale factor fitted on the calibration studies removes about a quarter of all natural errors before any agent runs (Appendix M.3).

Where the methods separate is repair. In the very same runs, MedGauge repairs nearly half of the injected faults, whereas no baseline repairs more than a few, giving MedGauge a usable output more than 20 percentage points above every baseline (Table A13). In short, MedGauge matches the baselines where no check applies and is clearly ahead wherever one does.

We retain injected faults as the primary benchmark because only a known failing stage and error size allow silent-error and repair rates to be measured directly. The natural-case audit now complements it for every method and supports the same conclusion on real errors.

AuthorsOpenReview ↗

Response to Reviewer aGTa (2/2)

"It is unclear how much of the improvement requires the proposed framework rather than a conventional enforcement system with well-designed checks." / "How would MedGauge compare with ToolGate or AgentSpec implementing the same measurement checks and repair conditions?"

Thank you for this question, which helped us sharpen where our contribution lies. We ran AgentSpec with our exact checks on abdominal CT, and the results show that the improvement comes from the contract, whichever engine enforces it (Section 4.4, Appendix L.2). Between ToolGate and AgentSpec, we chose AgentSpec because it supports both responses to a violation: stopping the episode, which reproduces a post-condition gate like ToolGate, and returning the violation to the agent for reflection, which is the closest existing mechanism to repair. We ran the authors' AgentSpec implementation and replaced only its LangChain executor with our session loop. All rows below use the same agent, tools, channels and prompt at the calibrated 15% threshold (Appendix M.2), and vary only the enforced rule and the engine.

EngineWhat is enforcedFaults repaired, of 131Usable output
AgentSpecConventional rule: block on any alarm, agent reflects335.5%
AgentSpecConventional rule: block on any alarm, episode stops as in ToolGate034.4%
AgentSpecOur contract6163.7%
MedGaugeOur contract6063.7%

A conventional rule over the same checks preserves safety, but repairs almost nothing. None of the four configurations signs a wrong value. The first two rows represent the conventional enforcement system with well-designed checks described in your comment. Because a conventional rule blocks after any alarm, it cannot distinguish an alarm already cleared by a corrective call from one that still stands, so it blocks both. Faulty measurements are withheld without repair, and half of the correct cases that trigger an alarm are withheld as well.

With our contract, AgentSpec matches MedGauge on both safety and repair. In our contract, each alarm declares its scope and the call that clears it, and the commit check verifies at submission that every blocking alarm has been cleared by that call. When a submission is rejected, the agent can run the corrective call and resubmit. Thus, the repair conditions in your question are the observation contract introduced in our paper. Existing enforcement frameworks provide the mechanism to gate an action. Our contribution defines what that gate must check on a measured value so that a blocked measurement can be repaired and signed.

The contract is portable, and our engine runs it at lower cost. Because the contract is a declarative specification that any enforcement engine can check, it can be adopted directly by agents built on existing frameworks. Our lightweight engine reaches the same accuracy in about a third fewer turns and at a third lower cost, because it returns each uncleared alarm together with the exact call that clears it (Table A10b). The abstract, Contribution 1 and Section 2 now highlight this result.

"In first sentence of abstract, 'Language-model agents increasingly operate ...' sounds AI-patterned/generated." / "Figure 1, Figure 1a,b, and Appendix A in Introduction can be hyperlinked."

Thank you for catching both points. The abstract now opens with: "When a language-model agent runs a medical imaging pipeline, it must decide whether each number the pipeline returns, such as a ventricular volume or a cardiothoracic ratio, can be reported as trusted." Every reference to a figure, table, section or appendix is now hyperlinked, and we tightened the prose across the manuscript.

Thank you again for questions that made our contribution much clearer. We hope these new results address your concerns, and we would be grateful if you would take them into account in your assessment.

Thank you for running the comparisons I asked for. The CT results make it clearer which errors the checks still miss, and the AgentSpec experiment convinced me that the repair rules make a real difference. I’m raising my score to weak accept.

Thank you very much for taking the time to read our response and for updating your assessment. We really appreciate your thoughtful feedback throughout the review process.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We sincerely thank all three reviewers for their careful reading and constructive questions. We appreciate Reviewer aGTa's positive feedback on the structured ablations and the CT repair result, Reviewer DUim's recognition of separating reasoning from commit authority and of repair over blocking, and Reviewer pmtY's assessment that the solution is practical.

During the discussion period we ran five new experiments and revised the paper. Changes in the PDF are marked in blue, and all section and table numbers below refer to the revised manuscript. The method and every number in the original tables are unchanged. In the main text, we added a step-by-step example in Section 3.1, reported the new experiments in Sections 4.2 and 4.4 with brief mentions in the abstract, introduction and conclusion, added one baseline row to Table 1, cited three related papers, and polished the wording for clarity. Full experimental details appear in Appendices L.2 and M, and clinical background for readers outside medical imaging appears in Appendix A0.

ConcernRaised byWhat we addedWhere
Natural errors scored against expert annotations, inside and outside coverageaGTa, DUim, pmtYEvery method of Table 1 scored against AMOS22 expert volumes, with the coverage threshold calibrated on 200 annotated studiesSection 4.2, Appendices M.1 and M.2
Source of the remaining natural errorsaGTa, DUimAnalysis of the missed tissue and a per-organ calibration of the segmentation toolSection 5, Appendix M.3
Independently trained second pathDUimAn nnU-Net trained on BTCV, evaluated across all 300 annotated CT studiesAppendix M.4
Same checks in an existing enforcement frameworkaGTa, pmtYAgentSpec enforcing our contract, compared against a conventional block-on-alarm rule over the same checksSection 4.4, Appendix L.2
Deterministic controller baselinepmtYA rule controller without a language model, added to the main comparisonTable 1
Clinical background and readabilityDUim, pmtYAppendix A0 with a glossary, a step-by-step CT example, inline definitions and expanded notationAppendix A0, Section 3, Table A1
Related work on formal verificationpmtYDiscussion of ShieldAgent, FormalJudge and RvLLMSection 2, Appendix N

Together, the new experiments establish three points.

The guarantee holds on real pipeline errors. After calibration, 35 errors across the 161 natural CT studies fall inside coverage, including a kidney measured at 6 ml against 344 ml in the expert annotation, and MedGauge signs none of them as trusted under any tested language model. Having the checks alone is not enough: without our contract, ReAct with the same channels signs 10 of the 15 covered errors on the main benchmark under Llama-3.3-70B.

The gain comes from the contract, which runs on an existing engine. Enforcing our contract in AgentSpec matches MedGauge on both safety and repair. Enforcing a conventional block-on-alarm rule over the same checks preserves safety, but repairs only 3 of 131 faults against 61 under our contract. Repair requires each alarm to declare its scope and the call that clears it, which is what our contract provides.

Repair is what makes safety useful. A deterministic rule controller without a language model reaches zero silent errors on two of the three tasks by withholding every flagged value, so it repairs nothing and blocks at least half of the correct cases that trigger a check. MedGauge is at least as safe on every task and raises usable output by 24 to 31 percentage points.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.