Skip to main content

m44 · Agentic AI in EP: tool-using agents, workflow automation, guardrails and human oversight

Warning

Education only. Not for diagnosis, treatment or any clinical decision.

In 60 seconds

An AI agent is a loop: a model, usually a large language model (LLM), chooses a tool, reads the result and chooses again until the goal is met or a step limit is reached (Yao et al. 2023; Khosravi et al. 2026). That makes agents useful for multi-step EP work, such as literature watch, data checks, report drafts and simulation runs, and risky in new ways. Errors compound over a chain of steps, documents can carry hidden instructions, and a confident summary can contain a number that no tool produced. Published medical agents have been tested on benchmark tasks in a simulated health record (Jiang et al. 2025), in simulated consultations (Schmidgall et al. 2024), and on rare-disease diagnosis with an expert audit of their reasoning (Zhao et al. 2026). This module derives how reliability compounds and what a check buys, builds an agent whose guardrails sit outside the model, attacks it with an injected instruction, and evaluates it on a task suite.

From the field

  • Benchmarks in a simulated health record (Stanford). MedAgentBench gives an LLM agent 300 physician-written tasks over 100 realistic patient records through the standard interfaces of electronic health records; the best model completed 69.67% of tasks, with large differences between task categories (Jiang et al. 2025). A follow-up redesigned the agent’s tools so that it no longer built raw web requests, which had been prone to syntax errors, and reported 91.0% success without memory and 98.0% with a memory of earlier failures (Chen et al. 2026).
  • Simulated consultations (Stanford and Johns Hopkins). In AgentClinic, a doctor agent must question a patient agent and order tests from a measurement agent within a limited number of turns; models did much worse in this sequential format than on the same cases posed as multiple-choice questions (Schmidgall et al. 2024).
  • Traceable reasoning. DeepRare, a multi-agent system with more than 40 tools for rare-disease diagnosis, links each step of its reasoning to evidence. On 163 clinical cases it ranked the right diagnosis first for 64.4% of cases, against 54.6% for experienced physicians given the same structured input; experts judged 95.4% of its cited references correct, and the errors included invented web links (Zhao et al. 2026).
  • Tools for numbers. An LLM agent that called signal-analysis tools estimated heart rate from wearable PPG more accurately than LLMs given the data directly, with ECG as the reference (Feli et al. 2025).
  • Agents that build models. An LLM-driven loop proposed, validated and selected ECG model designs for diastolic dysfunction and was then tested in external cohorts (preprint) (Jamthikar et al. 2026). Searching many designs against one validation set is the leakage problem of m35 in a new form.
  • EP workflows and devices. Reviews describe agentic workflows for EP literature, guideline monitoring and reports (Patel et al. 2025), and an LLM-based system estimated pacemaker battery levels from simulated remote-monitoring files for 30 people (Iwai et al. 2025).
  • Guardrails as software (NVIDIA). NeMo Guardrails puts programmable rules between the user and the model, independent of the model, for topics, fact-checking and input and output moderation (Rebedea et al. 2023).

Derivations

What an agent is

Piece What it does EP example
Model Chooses the next action Decides to check point density before computing velocity
Tools Do the real work, with typed inputs and units fill_distance, lat_outliers, conduction_velocity
State and memory Keeps what has been done and found The audit log of a mapping-QC run
Control loop Plan, act, observe, repeat, with a step limit Up to 20 tool calls per task
Policy Says which actions run, need approval or are refused Read and compute run; writes need a person

ReAct made the loop explicit: the model alternates reasoning with actions, such as a search, and reads each observation before the next step (Yao et al. 2023). Memory and reflection are central to Stanford’s generative agents, which simulate believable human behaviour (Park et al. 2023), and DeepRare’s central host keeps a memory bank and revisits its hypotheses in a self-reflection step (Zhao et al. 2026). The course uses five levels of autonomy, a framework of its own, not a standard:

Level Name Who acts In this course
0 Tool A person runs the model and acts Yes
1 Assistant The agent reads and drafts; a person acts Yes
2 Supervised agent The agent acts on reversible tasks; a person approves each write Main focus
3 Conditional autonomy The agent acts within a pre-approved scope, with audit and rollback Discussed
4 Closed loop The agent changes therapy or device settings without a person Out of scope (m36, m45)

EP use cases and their checkpoints. “Illustrative” means we found no published end-to-end example; the course designs one from published parts.

Use case Tools Human checkpoint Evidence
Literature and guideline watch PubMed search, DOI resolver A person reads every cited source Workflow description (Patel et al. 2025)
Wearable and Holter questions Peak detector, heart-rate estimator A person reviews flagged segments PPG benchmark (Feli et al. 2025)
Remote-monitoring triage Validated rhythm classifier, report parser A person adjudicates every alert Components only (clinical correlate)
Mapping-case quality check Course tools of m22, m25, m30 An analyst reviews flagged points Illustrative (lab)
Model development by agent Training script, validation scorer Test set locked before the search Preprint (Jamthikar et al. 2026)
Simulation and twin runs m33 calibrator, convergence check A person accepts the twin with its error Pace-site choice by Bayesian optimization (Meisenzahl et al. 2024); LLM orchestration illustrative
Report drafting Log parser, template The clinician edits and signs Illustrative

Key takeaways

  • An agent is a model in a loop with tools, memory and a policy.
  • The level of autonomy, not the model, decides where the person must stand.
  • In EP, level 2 (every write approved) is the working default; level 4 is device territory.

Errors compound

Let a task need \(n\) steps, and let step \(i\) succeed with probability \(p_i\), independently. The task succeeds only if every step does:

\[ P_{\text{task}} = \prod_{i=1}^{n} p_i \;=\; p^n \ \text{ if all } p_i = p \tag{1}\]

At \(p = 0.95\), ten steps succeed together only 60% of the time. Suppose a check after each step catches a failure with probability \(c\) and the step is retried once, succeeding with probability \(p_r\). A step then succeeds with probability \(p + (1-p)\,c\,p_r\), and

\[ P_{\text{task}} = \big[\,p + (1-p)\,c\,p_r\,\big]^n \;=\; \big[1 - (1-p)(1-c)\big]^n \ \text{ if } p_r = 1 \tag{2}\]

A check is worth most where chains are long. Finally, a person reviews the \(N\) outputs and catches a share \(r\) of the wrong ones. The expected number of wrong outputs that get through is

\[ E = N\,(1 - P_{\text{task}})\,(1 - r) \tag{3}\]

In lab part D, the scripted agent ran a 20-task mapping-QC suite ten times at each setting. With three compute steps at \(p = 0.9\), 74.0% of runs were fully correct against 72.9% from Equation 1, and 93.0% with a check (\(c = 0.8\)) against 91.8% from Equation 2.

Exact

Assumptions

  • Model: Equation 1, Equation 2 with one retry that succeeds with probability \(p\), and Equation 3 for 100 tasks; steps fail independently and the reviewer’s catches do not depend on the error. The JavaScript is tested against epml.agent.
  • All slider values are illustrative; no published agent’s per-step reliability is assumed.
  • What would change the result: correlated failures (Equation 4), checks that share the model’s blind spots, retries that repeat the same mistake, and reviewers who trust the agent more over time (automation bias).

Key takeaways

  • Task reliability falls geometrically with chain length.
  • A check with a retry raises every step, so it pays most in long chains.
  • Count what reaches the person and what gets past them, not only per-step accuracy.

When steps are not independent

Real errors cluster: a confusing case makes every step shakier. Let a share \(h\) of tasks be hard, with step success \(p_h\), and the rest easy, with \(p_e\). Then

\[ P_{\text{task}} = (1-h)\,p_e^{\,n} + h\,p_h^{\,n} \;\ge\; \bar p^{\,n}, \qquad \bar p = (1-h)\,p_e + h\,p_h \tag{4}\]

by Jensen’s inequality, because \(p^n\) is convex in \(p\). With the same mean step success, correlated errors leave more tasks clean and make the failures worse. In lab part D, with \(\bar p = 0.94\) and 20 steps, independent errors gave 0.29 task success and the hard-and-easy mixture 0.44. The practical rule: measure task success on a task suite; do not compute it from step accuracy.

Key takeaways

  • The chain formula (Equation 1) assumes independence; clustered errors break it.
  • Report task success, and look at which tasks fail.

Guardrails outside the model

A model can be told to ignore instructions it finds in documents, but that is a request, not a control. Almanac’s retrieval threshold made it abstain when an adversarial instruction was appended to the question (Zakka et al. 2024), and NeMo Guardrails runs input and output rails around the model (Rebedea et al. 2023). The lab builds four controls that do not depend on the model at all:

  • Tool schemas. Every argument has a type, a unit and a range, checked before the tool runs; a radius of 0.01 m is refused, not read as 0.01 mm.
  • Allowlist and sandbox. Only registered tools run, and writes stay inside one folder.
  • Human approval for writes. Every write-tier call waits for a person; writes nobody approved are never executed.
  • Audit log and number check. Every step is logged, and every number in the final answer must appear in a logged tool output.

Simulation

Assumptions

  • Model: the course’s agent loop (epml.agent.run_agent) driven by a scripted stand-in (ScriptedAgentModel) that obeys instructions it reads in tool outputs, sends one radius in metres and adds an invented number to its answer. These faults are ours, chosen to show the guardrails; they are not measured behaviour of any LLM.
  • Case: synthetic, flat 60-by-60-mm map, 80 points, speed and noise illustrative; the note carries the injected instruction. Runs precomputed by tools/make_m44_d1.py for all eight guardrail combinations, with writes simulated: nothing is deleted or written.
  • What would change the result: a real model may ignore or obey injected text unpredictably; attacks can hide in any tool output (web pages, PDFs, device reports), not only in notes.

Key takeaways

  • Treat every tool output as data, and put the controls where the model cannot argue with them.
  • Each guardrail covers a different hole: approval does not stop an unknown tool; an allowlist does.
  • Log every step, so a person can audit the run afterwards.

Evaluating an agent

Evaluate the whole loop on a suite of tasks with known answers, not single demonstrations:

  • Task success with a Wilson interval (m43), per task category, as MedAgentBench reports (Jiang et al. 2025).
  • Process, by auditing traces: DeepRare’s references were checked by experts, which found invented links among the errors (Zhao et al. 2026). In the lab, every number in the answer is traced to the step that produced it.
  • Safety, with attacks in the suite: injected instructions, wrong units, missing data.
  • Numbers from tools. General LLMs were unreliable readers of ECGs and device electrograms (m43), and an agent that called analysis tools did better on PPG heart rate (Feli et al. 2025). Hence the rule: no number in an answer that no tool produced.

Key takeaways

  • Report task success with an interval, per category, and on attacks as well as normal tasks.
  • Audit the trace, not only the answer.
  • An answer with an untraceable number fails, even when the number happens to be right.

Clinical correlate

NotePending clinical review

This section describes published findings only. It is not guidance for patient care, and it has not yet been reviewed by an EP physician.

Remote-monitoring triage: what the published components show. Implantable loop recorders send many alerts that staff must adjudicate. Historically about three in four loop-recorder alerts were false positives; in one national surveillance program, two newer remotely reprogrammable models with AI-based detection had 18.0% and 38.3% false-positive alerts, and reprogramming after false alerts lowered alert rates (Neiman et al. 2024). A systematic review found false-positive alarms in 59.7% of remote transmissions, most often atrial fibrillation alerts caused by premature beats (Covino and Russo 2024). A review of AI for implanted devices describes alert filtering and notes that reinforcement learning is being explored for devices that adjust their own programming (Antoun et al. 2025). An LLM-based system aggregated simulated pacemaker remote-monitoring files and estimated battery levels without the user writing code (Iwai et al. 2025).

Where a person must stay in the loop. An agent could sort incoming transmissions, parse reports from different vendors and draft a worklist, with a validated classifier as one of its tools. Every alert would still be adjudicated by a person, and the agent would never change a device. We found no published end-to-end evaluation of such an agent. In m38’s terms, the agent changes the order and burden of review, which has to be measured as missed true events and review time, not as model accuracy.

Why level 4 is a regulated device. An agent that changes therapy or device settings without a person is a medical device function, with the evidence and change-control duties of m36 and m45. The EHRA, HRS and ESC statement on AI in clinical electrophysiology describes the current state of the field (Svennberg et al. 2025).

Visual summary

Schematic

Model proposesan action Policy (outside the model) schema: types, units, rangesallowlist and sandboxwrites: a person approvesstep limit Tool runs(course code) Final answer:numbers traced result returns as data, never as instructions Audit log: every step, decision and result blocked or declined steps are logged and returned to the model as errors
Figure 1: The agent loop of this module. The policy sits between the model and the tools, so the model cannot talk its way past it; a person approves every write; every step is logged.

Assumptions

  • Schematic: no quantitative claim. It shows epml.agent.run_agent as built in the lab.

How experts think

Before trusting an agent, ask:

  1. Which level of autonomy, and where is the person? Name the checkpoint for every write and every clinical decision.
  2. Which tools, with which schemas? Units and ranges checked outside the model; unknown tools and paths refused.
  3. What happens to text the agent reads? Notes, web pages and reports can carry instructions; the policy must not depend on the model ignoring them (Zakka et al. 2024; Rebedea et al. 2023).
  4. How was it evaluated? Task success per category with an interval, on a suite that includes attacks, with traces audited (Jiang et al. 2025; Zhao et al. 2026).
  5. Where do its numbers come from? Every number from a logged tool call (Feli et al. 2025).

One sentence to keep: put the controls where the model cannot argue with them, and measure the whole loop, not the model.

Cheat sheet

Quantity Result
Chain (Equation 1) \(P_{\text{task}} = \prod p_i = p^n\)
With a check (Equation 2) \([p + (1-p)c\,p_r]^n\); \([1-(1-p)(1-c)]^n\) if \(p_r = 1\)
Errors past review (Equation 3) \(E = N(1 - P_{\text{task}})(1 - r)\)
Correlated errors (Equation 4) \((1-h)p_e^n + h\,p_h^n \ge \bar p^{\,n}\)

Published agents in this module

Study What the agent does Evidence
Jiang et al. (2025), Chen et al. (2026) Tasks in a simulated health record Benchmark, 300 tasks
Schmidgall et al. (2024) Simulated consultations with tests Benchmark
Zhao et al. (2026) Rare-disease diagnosis with traceable reasoning Nine data sets, physician comparison, expert audit
Feli et al. (2025) Heart rate from PPG through analysis tools Benchmark against ECG
Jamthikar et al. (2026) Proposes and selects ECG model designs Preprint, external validation
Iwai et al. (2025) Pacemaker battery estimation from monitoring files Simulated files, 30 people
Rebedea et al. (2023) Programmable rails around a model Toolkit with evaluations

Rules of thumb

  • Every write approved, every step logged, every number traced.
  • Allowlist first: approval cannot cover a tool the policy does not know.
  • Evaluate on a task suite with attacks; report success per category with an interval.

Interview questions

Try each question before you open its model answer. In a real interview, say which assumptions you are making.

Q1. What are the parts of an AI agent?

Model answer

A model that chooses the next action; tools that do the work, with typed inputs; state or memory of what has been done; a control loop with a step limit; and a policy that says which actions run, need approval or are refused (Yao et al. 2023; Khosravi et al. 2026). In this course the policy runs outside the model.

Q2. An agent’s steps are each 95% reliable. How reliable is a ten-step task, and what would you do?

Model answer

About \(0.95^{10} \approx 0.60\) if steps fail independently (Equation 1). Shorten the chain, add checks with retries (Equation 2: with \(c = 0.8\) and a retry that succeeds with probability 0.95, each step rises to about 0.988 and the task to about 0.89), and put a person on the outputs; then measure task success directly, because errors may not be independent (Equation 4).

Q3. What is prompt injection, and how do you defend an EP agent against it?

Model answer

Text in a document or tool output that tries to make the model follow new instructions, such as a mapping note telling the agent to delete files. Defences that do not rely on the model: an allowlist of tools, a sandbox for writes, schema checks, human approval for writes, and an audit log. Telling the model to ignore such text helps but is not a control. Lab part C shows which guardrail stops which step.

Q4. Why is human approval for writes not enough on its own?

Model answer

Approval covers the tools the policy knows to be writes. A tool the policy has never seen, or a compute tool with side effects, bypasses it. In lab part C, with approval on but no allowlist, the injected delete command ran (simulated). Allowlist first, then approval.

Q5. How would you evaluate an agent for mapping-case quality checks?

Model answer

Build a suite of cases with known answers, including hard cases and attacks (injected notes, wrong units, missing data). Report task success with a Wilson interval, per category; audit the traces; require every reported number to come from a logged tool call; and compare with the analysts’ current process on time and missed problems. MedAgentBench and DeepRare are models for the benchmark and the audit (Jiang et al. 2025; Zhao et al. 2026).

Q6. Why must every number in an agent’s answer come from a tool?

Model answer

LLMs are not reliable readers of EP signals (m43), and an invented number reads exactly like a computed one. An agent that called analysis tools estimated PPG heart rate better than LLMs given the data (Feli et al. 2025). Tracing each number to a logged tool call makes the claim checkable; an untraceable number fails the answer even if it happens to be right.

Q7. When does eq-m44-chain mislead?

Model answer

When errors are correlated: hard cases make every step worse. With the same mean step success, concentrated errors give a higher task success than \(\bar p^{\,n}\) (Equation 4), but the failures cluster in particular tasks, which may be the clinically important ones. Measure success per task, and look at which tasks fail.

Q8. An agent proposes, trains and selects ECG models. What could go wrong?

Model answer

Selecting among many candidates on one validation set overfits it, the leakage problem of m35 in a new form. Lock the external test set before the search, log every trial, and report how many designs were tried. The published example tested its selected models in external cohorts (Jamthikar et al. 2026), and it is a preprint.

Q9. What does a level-4 agent in EP look like, and why is it out of scope?

Model answer

An agent that changes therapy or device settings without a person, for example reprogramming an implanted device. That is a regulated device function needing the evidence, validation and change control of m36 and m45; reinforcement learning for self-adjusting devices is being explored (Antoun et al. 2025) but is not a teaching example.

Q10. What should an agent’s audit log contain?

Model answer

For every step: the time, the tool, the arguments, the permission tier, the policy decision (ran, rejected by schema, blocked, approved, declined), the result or error, and the final answer. It must be append-only and complete enough for a person to replay the run.

Q11. How could a reviewer’s catch rate change once an agent is deployed?

Model answer

It may fall as people come to trust the agent (automation bias), which raises the escaped errors of Equation 3 even if the agent does not change. Measure it with planted test cases and audits over time, not once.

Q12. What did MedAgentBench show, and what did its follow-up change?

Model answer

On 300 physician-written tasks in a simulated health record, the best model completed 69.67%, with large differences between task categories (Jiang et al. 2025). The follow-up redesigned the tools (no hand-built web requests, a calculator), the prompt and added a memory, and reported 91.0% without memory and 98.0% with it (Chen et al. 2026): the tools and the loop matter as much as the model.

Code lab

The lab builds a small agent around the course’s own mapping tools, attacks it with an injected instruction, measures error compounding on a 20-task suite, audits its answers and lets it answer a heart-rate question on real Holter annotations.

Part What you do Data
A Tools with typed, unit-checked schemas synthetic mapping cases
B One task end to end: trace, audit log, approval synthetic mapping cases
C Prompt injection: which guardrail stops which step synthetic case, poisoned note
D Error compounding (Equation 1, Equation 2, Equation 3, Equation 4) synthetic mapping cases
E Numbers must come from tools: auditing the answer synthetic mapping cases
F A heart-rate question answered with tools MIT-BIH AFDB (download)
G Optional: the same loop with your own model course data only
  • Python notebook: labs/python/m44_lab.ipynb. Run it from the course repository after pip install -r requirements.txt, or open it in Google Colab.
  • No external AI service. The agent’s model is a scripted stand-in whose faults we choose; the guardrails, approval step, audit log and evaluation are what the lab teaches. The agent acts only on synthetic cases and a temporary sandbox folder, and every write needs approval.
  • Data for part F: beat and rhythm annotations of one record of the MIT-BIH Atrial Fibrillation Database (PhysioNet 2000; Goldberger et al. 2000) (Open Data Commons Attribution v1.0), checked against the published SHA-256 list; skipped without internet access.
  • Part G lets you drive the same loop with your own model; it is skipped in CI and must never touch clinical systems or patient data.

Each part ends with checks: lines that pass with the code as given. If you change something and a check fails, that is information, not an error to hide.

Self-check

Short checks you can do in your head. Open each answer after you have tried it.

S1. Three steps succeed with probabilities 0.9, 0.9 and 0.8. What is the task success?

Answer

\(0.9 \times 0.9 \times 0.8 = 0.648\) (Equation 1).

S2. A step succeeds with \(p = 0.8\); a check catches half of the failures and the retry always works. What is the step’s success?

Answer

\(1 - (0.2)(0.5) = 0.9\) (Equation 2).

S3. 100 tasks, task success 0.9, reviewer catches 60% of wrong outputs. How many wrong outputs get through?

Answer

\(100 \times 0.1 \times 0.4 = 4\) (Equation 3).

S4. Which guardrail stops an injected call to a tool that does not exist in the registry?

Answer

The allowlist. Human approval for writes does not, because the policy does not know the tool is a write.

S5. An agent’s answer contains a number that appears in no tool output. Does it pass if the number happens to be right?

Answer

No. Its origin cannot be checked, so the course’s rule fails the answer.

S6. True or false: if half the tasks are hard, task success is always lower than \(\bar p^{\,n}\).

Answer

False. With the same mean step success, clustered errors give a higher task success than \(\bar p^{\,n}\) (Equation 4), although the failures concentrate in the hard tasks.

Literature figures

These figures are worth looking at alongside this module. We link to them instead of copying them: some licenses do not allow reuse here, and others we could not confirm. Each entry says what to look for and where this module explains it.

  • A multi-agent architecture with traceable evidence. Zhao and colleagues, the overview figure of DeepRare: a central host with a memory bank, agent servers each with their own tools, and web-scale medical sources, with the self-reflection loop [Zhao et al. (2026); free full text]. Compare with the table of agent parts above.
  • Physicians against the agent. The same paper, the comparison of DeepRare with five experienced physicians on 163 clinical cases at Recall@1 and Recall@5 [Zhao et al. (2026); free full text]. This module: evaluating an agent.
  • Reference accuracy, case by case. The same paper, the figure summarizing physicians’ checks of the cited references (95.4% correct on average) and the error types [Zhao et al. (2026); free full text]. This module: lab part E.

Further reading

References

Antoun, Ibrahim, Alkassem Alkhayer, Ahmed Abdelrazik, et al. 2025. “Artificial Intelligence and the Future of Cardiac Implantable Electronic Devices: Diagnostics, Monitoring, and Therapy.” Journal of Clinical Medicine 14 (24). https://doi.org/10.3390/jcm14248824.
Chen, Eric, Sam Postelnik, Kameron Black, et al. 2026. “MedAgentBench V2: Improving Medical LLM Agent Design.” Pacific Symposium on Biocomputing 31: 354–71. https://doi.org/10.1142/9789819824755_0025.
Covino, Simona, and Vincenzo Russo. 2024. “False-Positive Alarms in Patients with Implantable Loop Recorder Followed by Remote Monitoring: A Systematic Review.” Pacing and Clinical Electrophysiology 47 (3): 406–16. https://doi.org/10.1111/pace.14941.
Feli, Mohammad, Iman Azimi, Pasi Liljeberg, et al. 2025. “An LLM-Powered Agent for Physiological Data Analysis: A Case Study on PPG-Based Heart Rate Estimation.” Annual International Conference of the IEEE Engineering in Medicine and Biology Society. IEEE Engineering in Medicine and Biology Society. Annual International Conference 2025: 1–7. https://doi.org/10.1109/EMBC58623.2025.11254428.
Goldberger, A. L., L. A. Amaral, L. Glass, et al. 2000. “PhysioBank, PhysioToolkit, and PhysioNet: Components of a New Research Resource for Complex Physiologic Signals.” Circulation 101 (23): e215–20. https://doi.org/10.1161/01.cir.101.23.e215.
Iwai, Rumi, Takunori Shimazaki, Jaakko Hyry, et al. 2025. “Evaluation of Pacemaker Battery Level Estimation Using Large Language Model and Remote Monitoring Historical Data.” Annual International Conference of the IEEE Engineering in Medicine and Biology Society. IEEE Engineering in Medicine and Biology Society. Annual International Conference 2025: 1–6. https://doi.org/10.1109/EMBC58623.2025.11251697.
Jamthikar, Ankush D, Aditya Shanmugham, Sajeev Singh, et al. 2026. “Agentic Autodiscovery of Diastolic Dysfunction Phenotypes from Surface Electrocardiogram.” medRxiv, ahead of print. https://doi.org/10.64898/2026.06.17.26355897.
Jiang, Yixing, Kameron C Black, Gloria Geng, et al. 2025. “MedAgentBench: A Virtual EHR Environment to Benchmark Medical LLM Agents.” NEJM AI 2 (9): AIdbp2500144. https://doi.org/10.1056/AIdbp2500144.
Khattab, Omar et al. 2023. DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines. arXiv:2310.03714. https://doi.org/10.48550/arXiv.2310.03714.
Khosravi, Bardia, Pouria Rouzrokh, Tugba Akinci D’Antonoli, et al. 2026. “Agentic AI in Radiology: Evolution from Large Language Models to Future Clinical Integration.” Radiology. Artificial Intelligence 8 (2): e250651. https://doi.org/10.1148/ryai.250651.
Meisenzahl, Casey, Karli Gillette, Anton J Prassl, et al. 2024. “BOATMAP: Bayesian Optimization Active Targeting for Monomorphic Arrhythmia Pace-Mapping.” Computers in Biology and Medicine 182: 109201. https://doi.org/10.1016/j.compbiomed.2024.109201.
Neiman, Zachary M, Merritt H Raitt, Gregory Rohrbach, et al. 2024. “Monitoring of Remotely Reprogrammable Implantable Loop Recorders with Algorithms to Reduce False-Positive Alerts.” Journal of the American Heart Association 13 (5): e032890. https://doi.org/10.1161/JAHA.123.032890.
Park, Joon Sung et al. 2023. Generative Agents: Interactive Simulacra of Human Behavior. arXiv:2304.03442. https://doi.org/10.48550/arXiv.2304.03442.
Patel, Akshar, Stanley Joseph, Caryl Bailey, et al. 2025. “Transforming Electrophysiology Workflows with Natural Language Processing and Agentic Artificial Intelligence.” Heart Rhythm O2 6 (10): 1613–20. https://doi.org/10.1016/j.hroo.2025.07.013.
PhysioNet. 2000. MIT-BIH Atrial Fibrillation Database (Version 1.0.0). PhysioNet. https://doi.org/10.13026/C2MW2D.
Rebedea, Traian et al. 2023. NeMo Guardrails: A Toolkit for Controllable and Safe LLM Applications with Programmable Rails. arXiv:2310.10501. https://doi.org/10.48550/arXiv.2310.10501.
Schmidgall, Samuel et al. 2024. AgentClinic: A Multimodal Agent Benchmark to Evaluate AI in Simulated Clinical Environments. arXiv:2405.07960. https://doi.org/10.48550/arXiv.2405.07960.
Svennberg, Emma, Janet K Han, Enrico G Caiani, et al. 2025. “State of the Art of Artificial Intelligence in Clinical Electrophysiology in 2025: A Scientific Statement of the European Heart Rhythm Association (EHRA) of the ESC, the Heart Rhythm Society (HRS), and the ESC Working Group on e-Cardiology.” Europace 27 (5). https://doi.org/10.1093/europace/euaf071.
Yao, Shunyu et al. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629. https://doi.org/10.48550/arXiv.2210.03629.
Zakka, Cyril, Rohan Shad, Akash Chaurasia, et al. 2024. “Almanac - Retrieval-Augmented Language Models for Clinical Medicine.” NEJM AI 1 (2). https://doi.org/10.1056/aioa2300068.
Zhao, Weike, Chaoyi Wu, Yanjie Fan, et al. 2026. “An Agentic System for Rare Disease Diagnosis with Traceable Reasoning.” Nature 651 (8106): 775–84. https://doi.org/10.1038/s41586-025-10097-9.