🤖 machine learning

Automatic Construction of Clinical Scoring Systems with LLM Agents

This paper introduces AgentScore, an LLM agent framework that automatically constructs deployable, unit-weighted clinical scoring systems by combining semantic rule generation with data-grounded verification, achieving performance comparable to flexible models while adhering to the strict interpretability and workflow constraints required for routine clinical use.

Original authors: Silas Ruhrberg Estévez, Christopher Chiu, Mihaela van der Schaar

Published 2026-05-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Silas Ruhrberg Estévez, Christopher Chiu, Mihaela van der Schaar

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a doctor rushing through a busy emergency room. You need to make a quick decision about a patient's risk level, but you don't have time to pull out a calculator, open a complex app, or remember a formula with five different numbers multiplied by different weights. You need a simple checklist: "If the patient has symptom A, add one point. If they have symptom B, add one point. If the total is 3 or more, call for help."

This is what clinical scoring systems are: simple, memorable checklists that doctors use at the bedside.

However, modern Artificial Intelligence (AI) is great at predicting risks, but it usually works like a "black box" with complex math that is impossible to do in your head. The authors of this paper, Silas Ruhrberg Estévez and colleagues, noticed a gap: we have powerful AI, but we can't easily turn it into the simple checklists doctors actually use.

Here is how they solved it, using a creative new method called AgentScore.

The Problem: The "Chef" vs. The "Taste Tester"

Usually, when scientists try to build these checklists, they either:

Ask experts to manually pick the rules (slow and hard to update).
Use AI to find patterns, but the AI suggests complex math (like "Age × 0.4 + Blood Pressure × -0.2") that is hard to use in a real hospital.

The authors realized that to build a good checklist, you need two things working together:

Creativity: Someone who can imagine new, clever combinations of symptoms (e.g., "What if we compare the heart rate to the blood pressure?").
Rigorous Testing: Someone who strictly checks if that idea actually works with real data and isn't just a lucky guess.

The Solution: AgentScore (The AI Team)

The paper introduces AgentScore, which acts like a small, specialized team of AI agents working together to build these checklists from scratch.

Think of it like a cooking competition where the goal is to create the perfect, simple recipe that anyone can follow.

The "Chef" Agent (The LLM Proposer):
This is a Large Language Model (like the AI behind this explanation). Its job is to be creative. It looks at the patient data and says, "Hey, what if we check if the patient's breathing is faster than 30 breaths?" or "What if we check if their kidney function dropped by 20%?"
- Crucial Rule: The Chef is not allowed to see the actual patient names or private records. It only sees a summary of the data (like "the average heart rate is 80"). This keeps patient privacy safe.
- The Chef proposes a list of potential "rules" for the checklist.
The "Taste Tester" Agent (The Deterministic Verifier):
This is a strict, mathematical computer program. It takes the Chef's ideas and tests them against the real data.
- Does this rule actually predict who gets sick? (If not, it's thrown out).
- Is this rule just a copy of another rule? (If yes, it's thrown out to keep the list short).
- Is the rule simple enough to be written on a piece of paper? (If it's too complex, it's thrown out).
The "Head Chef" Agent (The Assembler):
Once the Taste Tester has a pool of good, verified rules, this agent picks the best combination. It builds the final checklist, ensuring it has a limited number of items (so it's easy to remember) and that every item counts as exactly one point.

Why "One Point" Matters

The paper emphasizes that the best checklists are unit-weighted. This means every item on the list is worth exactly 1 point.

Bad Checklist: "Age > 65 gets 3 points, but low blood pressure gets -2 points." (Hard to do in your head).
AgentScore Checklist: "Age > 65? +1 point. Low blood pressure? +1 point. Total > 2? Call for help." (Easy to do in your head).

The authors found that these simple "1-point" lists are surprisingly powerful. They are almost as good at predicting outcomes as the complex, math-heavy AI models, but they are actually usable by humans.

The Results: Beating the Experts

The team tested AgentScore on eight different medical tasks (like predicting heart failure, kidney failure, or death in the ICU) using real hospital data.

Better than old methods: AgentScore created checklists that were more accurate than previous methods that tried to force complex AI into simple checklists.
Better than standard guidelines: On two specific tests, the checklists built by AgentScore were actually better at spotting high-risk patients than the official, long-standing medical guidelines currently used in hospitals.
Doctor Approval: When they showed the results to 18 real doctors, the doctors overwhelmingly preferred the AgentScore checklists. They said the AI-generated lists felt more natural, were easier to use at the bedside, and matched how doctors actually think.

The Bottom Line

The paper argues that we don't always need bigger, more complex AI to save lives. Sometimes, the best AI is the one that can translate its complex knowledge into a simple, paper-and-pencil checklist that a tired doctor can use in a split second.

AgentScore proves that by using AI to propose ideas and strict math to verify them, we can automatically build these simple, life-saving tools without needing a human expert to manually write every single rule.

Important Note: The authors are very clear that these are research tools. They are not yet approved for use in real hospitals to treat patients. They are a proof-of-concept showing a new way to build medical tools that are both smart and simple.

Technical Summary: Automatic Construction of Clinical Scoring Systems with LLM Agents

Problem Statement

Modern clinical practice relies on compact, evidence-based scoring systems (e.g., CURB-65, SOFA) composed of a small number of interpretable decision rules. These systems are designed for bedside execution, requiring memorability, auditability, and operation without computational aids. However, many high-performing machine learning (ML) models fail to translate into routine clinical use because they are misaligned with these workflow constraints. They often rely on inconsistently available inputs, require complex preprocessing, or produce continuous-weight computations that are difficult to execute manually.

Existing automated methods for learning clinical scores typically face a "generation-selection gap." Approaches like RiskSLIM or Optimal Checklists optimize over a fixed, pre-constructed feature matrix. They cannot automatically discover clinically meaningful derived rules (e.g., physiological ratios, temporal trends, or shallow logical compositions) from raw variables. Consequently, the burden of constructing the hypothesis space falls on manual feature engineering, limiting the coverage of the combinatorial rule space that clinical guidelines routinely consider.

The core challenge is to jointly optimize rule construction and checklist compatibility within a constrained model class (unit-weighted, unordered checklists) while navigating an exponentially large discrete search space that is intractable for exhaustive enumeration or standard gradient-based optimization.

Methodology: AgentScore

The authors introduce AgentScore, a framework that bridges Large Language Models (LLMs) and discrete optimization to automatically construct deployable clinical scoring systems. The system treats LLMs not as autonomous decision-makers, but as structured semantic proposal mechanisms embedded within a deterministic, data-grounded verification loop.

1. Rule Language and Constraints

AgentScore operates within a restricted, clinically motivated rule language $\mathcal{R}$ that supports:

Numeric thresholds and ranges: Standard cutpoints (e.g., $HR > 100$).
Categorical and binary presence rules: Diagnoses or comorbidities.
Physiological ratios and contrasts: Derived indices (e.g., $HR/BP$).
Count-based rules: M-of-N criteria (e.g., SIRS criteria).
Shallow logical compositions: Limited depth AND/OR operations to preserve memorability.
Temporal and distributional rules: Trends, deltas, and quantile-based thresholds derived from longitudinal data.

The target model is a unit-weighted N-of-M checklist: a sparse set of binary rules $S$ where the score is the count of satisfied rules ( $S(\tilde{x}) = \sum r_j(\tilde{x})$ ), and a decision is made if the score exceeds a threshold $\tau$ .

2. The AgentScore Pipeline

The learning procedure decomposes the problem into three stages (Figure 2):

Rule Proposal (LLM Agent): An LLM proposes candidate rules based on a dataset description and aggregate statistics provided via a tool interface. Crucially, the LLM never observes raw patient-level records, mitigating privacy risks and hallucination. It generates structured JSON rules adhering to the grammar.
Deterministic Validation & Filtering:
- Statistical Screening: Proposed rules are evaluated on held-out data. A rule is retained only if it meets a minimum discrimination threshold (e.g., AUROC $\ge 0.60$ ) and passes redundancy checks (Jaccard similarity on positive-class coverage) against the current pool.
- Clinical Plausibility Check: A second LLM agent acts as a "self-check" to reject rules that are statistically valid but clinically nonsensical or semantically incoherent.
Score Assembly (LLM Agent): A third agent selects a compact subset of rules from the retained pool to form the final checklist. This agent is guided to propose semantically diverse combinations (e.g., spanning respiratory, cardiovascular, and renal domains) rather than just statistically similar proxies.
Iterative Refinement: The assembly agent can iteratively refine the checklist, receiving feedback on discrimination and coverage metrics, until a stopping criterion is met. The final decision threshold $\tau$ is optimized automatically (e.g., maximizing Youden's J statistic).

3. Optimization Objective

The system seeks to maximize empirical clinical utility (e.g., AUROC, net benefit) subject to hard constraints:
$\max_{S \subseteq \mathcal{R}} U(S(\tilde{x}), y; D_{val}) \quad \text{s.t.} \quad |S| \le m, \text{Depth}(r) \le d$
This is an NP-hard, non-differentiable combinatorial problem. AgentScore addresses this by using the LLM to navigate the semantic structure of the rule space, alleviating the "cold start" problem of finding high-utility rules in a sparse landscape, while deterministic tools ensure statistical validity and deployability.

Key Contributions

Conceptual: The paper formalizes deployable clinical checklist learning as a joint combinatorial optimization problem over rule construction and subset selection, rather than just selection over fixed features. It explicitly encodes bedside cognitive and operational constraints (memorability, auditability, arithmetic-free use) into the hypothesis class.
Algorithmic: AgentScore introduces a framework where LLMs propose semantically structured candidates within a restricted grammar, while deterministic tools enforce grammar validity, statistical screening, and redundancy control. This separation ensures that the final score is both interpretable and empirically supported.
Empirical: The method is evaluated across eight clinical prediction tasks (MIMIC-IV, eICU) and two external validation tasks.

Experimental Results

Predictive Performance: Across eight tasks, AgentScore significantly outperforms existing score-generation baselines (RiskSLIM, FasterRisk, Optimal Checklists, AutoScore) and matches or exceeds flexible interpretable models (Logistic Regression, Decision Trees) despite operating under stricter structural constraints (unit weights, small rule counts).
Guideline Competitiveness: In external validation settings (PhysioNet 2012 ICU mortality and UK/Canadian Cystic Fibrosis cohorts), AgentScore achieved higher discrimination (AUROC) than established clinical guidelines (SOFA, SAPS-I, CF transplant guidelines) while remaining suitable for manual execution.
Deployability: A structured review by 18 practicing clinicians showed a significant preference for AgentScore-generated checklists over integer-weighted baselines (FasterRisk) regarding alignment with guideline-style reasoning (85%), ease of bedside application (71%), and deployment preference (81%).
Ablation Studies: Removing the constrained proposal-validation loop (replacing it with unconstrained LLM generation) caused a significant performance drop (Cohen's $d \approx 2.8$ ), confirming the necessity of the deterministic verification loop.

Significance and Claims

The paper argues that the gap between ML performance and clinical adoption is not due to insufficient predictive power, but to optimizing over model classes incompatible with guideline deployment. AgentScore demonstrates that constrained semantic optimization—where hypothesis class design, deployability, and verification are treated as first-class modeling concerns—can yield models that are both highly accurate and directly executable at the bedside.

The authors emphasize that their approach does not replace clinical guidelines but provides a pathway to automatically construct candidate scoring systems that align with guideline-style use and are suitable for prospective validation. The framework addresses key barriers to clinical ML adoption, including data governance (by decoupling LLMs from raw data access) and the "generation-selection" gap in rule discovery.

Limitations: The authors note that AgentScore is less expressive than flexible black-box models and may miss predictive relationships not semantically accessible to the LLM. It prioritizes deployability over formal optimization guarantees and does not inherently enforce fairness constraints, requiring external auditing. The scoring systems are research artifacts intended for validation, not immediate clinical deployment.