AutoMDT: Automation in Medical and Systems Domains

• AutoMDT is a multi-faceted term defining automation in medical decision-tree extraction, modular data transfer control, and continuous digital twin management.
• It employs methods ranging from end-to-end large language model generation to pipeline decomposition and deep reinforcement learning, adapting to diverse domain challenges.
• The paradigm enhances efficiency, accuracy, and scalability in clinical decision support, high-speed data routing, and proactive patient state synchronization.

AutoMDT is a context-dependent term in recent arXiv literature rather than a single standardized designation. In medical natural language processing, it denotes the automatic extraction of medical decision trees from clinical text through the Text2MDT task and its later parameter-efficient variants (Zhu et al., 2024, Li et al., 6 Oct 2025). In networking and systems research, it denotes a modular data transfer architecture that uses a deep reinforcement learning agent to optimize read, network, and write concurrency (Swargo et al., 7 Aug 2025). In medical digital twin research, an autonomous agent-orchestrated framework is presented as realizing the “AutoMDT vision” of a continuously synchronized, auditable, and secure medical digital twin (Chen et al., 28 Mar 2026). The shared label therefore spans distinct technical programs whose overlap is terminological rather than methodological.

1. Terminological scope and domain-specific meanings

The supplied literature uses the same label for different objects of study. One usage concerns medical decision trees (MDTs) as structured representations of clinical decision processes. A second usage concerns modular data transfer across distributed systems. A third usage appears in medical digital twins, where “MDT” stands for Medical Digital Twins rather than decision trees.

Usage of AutoMDT	Defining focus	Representative source
Medical decision-tree extraction	“automatic extraction of MDTs from medical texts such as medical guidelines and textbooks”	(Zhu et al., 2024)
Modular data transfer architecture	“simultaneously optimize concurrency levels for read, network, and write operations”	(Swargo et al., 7 Aug 2025)
Medical digital twin synchronization	“realizes the AutoMDT vision: a continuously synchronized, auditable, and secure medical digital twin”	(Chen et al., 28 Mar 2026)

This suggests that AutoMDT is best interpreted through local paper context. In medical NLP, the core problem is structured extraction from free text. In systems work, the core problem is runtime control of pipeline concurrency. In digital twin work, the focus is proactive state synchronization under auditable and secure orchestration.

2. AutoMDT as medical decision-tree extraction

In the medical NLP line of work, knowledge of the medical decision process is modeled as medical decision trees, and that knowledge is described as critical for building clinical decision support systems (Zhu et al., 2024). The formalization given for a medical decision tree defines a tree as

$T=(V,E,c,o),$

where $V=\{v_1,\dots,v_N\}$ is partitioned into decision nodes $V_{\text{dec}}$ and leaf nodes $V_{\text{leaf}}$, $E\subseteq V_{\text{dec}}\times V$ is the set of directed edges, $c:E\to C$ assigns edge conditions, and $o:V_{\text{leaf}}\to O$ assigns leaf outcomes (Zhu et al., 2024). This representation fixes the central extraction problem: identify node spans, directed branching structure, condition labels, and terminal outcomes from text.

The later FT-MDT formulation restates the same task as Text2MDT / AutoMDT and makes the output representation more explicit (Li et al., 6 Oct 2025). The input is a clinical guideline or textbook paragraph represented as a token sequence

$X=[x_1,x_2,\dots,x_{n_\text{text}}],$

and the output is a pre-order traversal

$T=[N_1,N_2,\dots,N_{n_\text{node}}],$

where each node captures one decision step. A node is represented as

$$\text{Node}=\{\text{Role},\text{Triplets},\text{Logical\_Rel}\},$$

with $V=\{v_1,\dots,v_N\}$0, $V=\{v_1,\dots,v_N\}$1, and $V=\{v_1,\dots,v_N\}$2 (Li et al., 6 Oct 2025). In that formulation, $V=\{v_1,\dots,v_N\}$3 marks a conditional assessment and $V=\{v_1,\dots,v_N\}$4 a therapeutic decision. The stated challenges are capturing hierarchical tree structure in text, precisely extracting medical terms and logical relations, and keeping a parameter-efficient footprint suitable for clinical deployment.

A notable feature of this literature is that the same conceptual object is represented at two granularities. The earlier formalization emphasizes graph structure and labeled edges; the later formalization emphasizes pre-order node sequences enriched with role, triplets, and logical relations. This suggests a shift from pure structure recovery toward sequence-generation views that are more compatible with instruction-tuned LLMs.

3. Architectures and algorithms in medical AutoMDT

The Text2MDT paper investigates two different methods for the task: an end-to-end framework and a pipeline framework (Zhu et al., 2024). The end-to-end framework relies on GPT-style LLMs for instruction tuning to generate all node information and tree structures. The structured exposition lists GPT2-medium-Ch (345M) and GPT-J 6B (bilingual) as the experimental models, trained with standard next-token cross-entropy and mixed precision, using 10 epochs, learning rate $V=\{v_1,\dots,v_N\}$5, and batch size 16. Its prompt template specifies a tabular output schema and a chain-of-thought preface: “First identify symptom spans, then link conditions step by step…”, with the Chinese preface “思考过程: 1. 定位症状 2. 判断阈值 3. 构建分支 … 最终输出:” (Zhu et al., 2024).

The pipeline framework decomposes Text2MDT into three subtasks. The node span detection stage uses Chinese BERT-base followed by BiLSTM and a CRF layer, optimized with the negative log-likelihood of the CRF tag sequence and evaluated by token-level $V=\{v_1,\dots,v_N\}$6. The edge relation classification stage considers every ordered pair $V=\{v_1,\dots,v_N\}$7 and classifies it into one of $V=\{v_1,\dots,v_N\}$8 using BERT-base plus a 2-layer MLP, with cross-entropy and contrastive margin loss, evaluated by precision and recall on directed edges. The tree assembly stage solves

$V=\{v_1,\dots,v_N\}$9

and enforces a single-root constraint with Chu–Liu/Edmonds’ algorithm (Zhu et al., 2024). This division of labor separates span extraction, relation prediction, and structural decoding.

FT-MDT retains the Text2MDT pipeline structure but introduces PI-LoRA (Path-Integrated LoRA) as a parameter-efficient fine-tuning method (Li et al., 6 Oct 2025). The backbone is described as Qwen 2.5B (7B parameters), frozen during supervised fine-tuning, with no extra prediction layers. PI-LoRA measures the importance of each LoRA module via a path-integrated gradient score. For a single LoRA parameter $V_{\text{dec}}$0, the importance score is

$V_{\text{dec}}$1

The approximation samples scaled parameter values, aggregates scores over training steps, computes a module-level average, prunes the lowest-scoring modules until only $V_{\text{dec}}$2 remain, and then retrains the surviving modules (Li et al., 6 Oct 2025). The paper characterizes this as capturing “synergistic” effects between different modules and allocating rank to the most critical components while pruning less important ones.

The two medical AutoMDT lines therefore occupy complementary positions. The earlier work introduces task structure, dataset normalization, end-to-end prompting, and classical structured decoding. The later work focuses on improving the adaptation mechanism of the LLM backbone while remaining within the Text2MDT problem setting.

4. Data, normalization, and reported performance in medical AutoMDT

The Text2MDT abstract frames the task as extraction from “medical texts such as medical guidelines and textbooks,” whereas the structured exposition describes a Chinese Text2MDT dataset with “1,200 de-identified Chinese electronic medical records (EMRs) covering common internal medicine scenarios” (Zhu et al., 2024). The annotation schema includes span-level labels for decision-node text, directed-edge annotations linking decision nodes to child nodes with edge-condition text spans, and leaf-node outcome spans. Reported inter-annotator agreement is Cohen’s $V_{\text{dec}}$3 on node spans and $V_{\text{dec}}$4 on edge links. The dataset statistics are 1,200 total documents, average 6.2 nodes per tree with $V_{\text{dec}}$5, and average 5.4 edges per tree with $V_{\text{dec}}$6. Normalization rules convert all numeric tokens to “<NUM>” and map measurement units to unified symbols such as “mmHg” to “<UNIT_PRESSURE>” (Zhu et al., 2024).

The evaluation protocol in the structured exposition uses a held-out test set of 200 documents. Reported results are: node detection precision 0.78, recall 0.75, and $V_{\text{dec}}$7 0.76; edge classification precision 0.71, recall 0.66, and $V_{\text{dec}}$8 0.68; full-tree exact match 0.61 for the pipeline and 0.47 for end-to-end GPT2-medium (Zhu et al., 2024). The same exposition reports that adding a chain-of-thought preface improves GPT2-medium’s $V_{\text{dec}}$9 from 0.47 to 0.53, and that BERT-small-Chinese (45M) combined with the edge classifier and tree assembly achieves full-tree $V_{\text{leaf}}$0, with “only 1/10 the parameters of GPT-J.” It also lists implementation tricks: synonym-replacement data augmentation, CRF label smoothing with $V_{\text{leaf}}$1, joint fine-tuning on node and edge objectives, and curriculum learning that trains node detection before adding edge classification (Zhu et al., 2024).

The abstract of the same paper states that “the end-to-end method basd on LLMs (7B parameters or larger) show promising results, and successfully outperform the pipeline methods,” and that chain-of-thought prompting improves performance on the Text2MDT test set (Zhu et al., 2024). The structured exposition’s GPT2-medium numbers do not match that summary. This suggests that the conclusions depend on model scale and experimental slice: the abstract explicitly refers to “7B parameters or larger,” whereas the detailed result table reports GPT2-medium.

FT-MDT reports substantially stronger scores on the Text2MDT corpus of clinical guidelines from Zhu et al. (2024), containing “≈1.2 K guideline sections, each annotated with full MDTs” (Li et al., 6 Oct 2025). In the pipeline setting, PI-LoRA reports Prec .911, Rec .916, $V_{\text{leaf}}$2 .913, NG_LR .981, Tree_Acc .772, DP_F1 .884, and Tree_LR .967, outperforming LoRA, AdaLoRA, AutoLoRA, MOELoRA, and DoRA on the Qwen-2.5B backbone. In the end-to-end setting, PI-LoRA reports Tree_Acc .550, DP_F1 .679, and Tree_ER .936. The same paper reports initial LoRA ranks $V_{\text{leaf}}$3 on all 224 modules, about 3.6M trainable parameters, or about 0.05% of 7B, and about 1.8M parameters after pruning 50% of modules (Li et al., 6 Oct 2025).

System	Setting	Reported result
Text2MDT pipeline	Held-out test set	Full-tree exact match 0.61
GPT2-medium	End-to-end	Full-tree exact match 0.47
GPT2-medium + COT	End-to-end	$V_{\text{leaf}}$4 from 0.47 to 0.53
BERT-small-Chinese + pipeline	Full tree	$V_{\text{leaf}}$5
PI-LoRA	Pipeline	Tree_Acc .772, DP_F1 .884, Tree_LR .967
PI-LoRA	End-to-end	Tree_Acc .550, DP_F1 .679, Tree_ER .936

Taken together, these results define the medical AutoMDT literature as a structured extraction problem whose quality depends jointly on representation choice, decoding regime, prompt design, and adaptation strategy.

5. AutoMDT as a modular data transfer architecture

In networking and systems research, AutoMDT is a “novel modular data transfer architecture” for rapid and dependable movement of massive datasets across geographically dispersed locations (Swargo et al., 7 Aug 2025). Its stated motivation is that monolithic transfer tools use a single concurrency parameter $V_{\text{leaf}}$6 for read, network, and write threads, which can cause under-utilization, TCP congestion, or end-system overload. The proposed architecture separates the transfer into three stages—read from source file system, network, and write to destination file system—and assigns them separate tunable knobs:

$V_{\text{leaf}}$7

The system architecture has three modules, I/O Read Module, Network Module, and I/O Write Module, coordinated by a DRL Agent (PPO) (Swargo et al., 7 Aug 2025). The read module launches $V_{\text{leaf}}$8 threads to pull chunks into a sender-side tmpfs buffer; the network module sends chunks over TCP with $V_{\text{leaf}}$9 concurrent sockets; the write module drains a receiver-side buffer to the final file system with $E\subseteq V_{\text{dec}}\times V$0 threads. Every second, the agent observes metrics including $E\subseteq V_{\text{dec}}\times V$1, sender and receiver buffer occupancy, and optionally RTT and packet loss, then suggests a new tuple $E\subseteq V_{\text{dec}}\times V$2.

The control problem is formalized as an MDP trained with Proximal Policy Optimization. The state is

$E\subseteq V_{\text{dec}}\times V$3

the action is a continuous adjustment

$E\subseteq V_{\text{dec}}\times V$4

and the action is clamped to valid thread ranges (Swargo et al., 7 Aug 2025). One reward form uses the utility

$E\subseteq V_{\text{dec}}\times V$5

with $E\subseteq V_{\text{dec}}\times V$6, and the agent maximizes the utility difference between consecutive steps. PPO training uses horizon 10 steps per episode, maximum 30,000 episodes, learning rate $E\subseteq V_{\text{dec}}\times V$7, batch size 2048, clip $E\subseteq V_{\text{dec}}\times V$8, Adam optimizer, entropy bonus $E\subseteq V_{\text{dec}}\times V$9, value loss weight $c:E\to C$0, and early stopping once at least 90% of theoretical maximum reward $c:E\to C$1 is reached for 1000 episodes (Swargo et al., 7 Aug 2025).

A central contribution is the lightweight network-system simulator for offline training. The simulator emulates three-stage buffer dynamics, uses an event-driven loop with a priority queue, and takes as inputs throughput-per-thread, buffer capacities, and link-level bandwidth cap. The workflow includes a 10-minute random-thread run to estimate stage maxima, bottleneck, and ideal thread counts, followed by PPO training. The reported offline convergence time is “on average 45 min,” contrasted with “days online” (Swargo et al., 7 Aug 2025). At runtime, the decision latency is reported as less than or equal to 5 ms, the policy and value networks occupy about 1 MB, and CPU overhead is 1–2%.

The evaluation uses CloudLab Wisconsin and FABRIC testbeds, large-file and mixed-file datasets, and bottleneck scenarios that throttle read, network, or write rates (Swargo et al., 7 Aug 2025). The reported quantitative results include target concurrency reached in 7 s for AutoMDT versus 62 s for Marlin, large-file transfer completion time 44 s versus 74 s for Marlin, and throughput stabilizing at 24 Gbps versus about 18 Gbps for Marlin. The comparative transfer table reports, for dataset A (1 TB), Globus 3.65 Gbps, Marlin 18.07 Gbps, and AutoMDT 23.99 Gbps, with 1.33× gain versus Marlin; for dataset B (1 TB), Globus 2.33 Gbps, Marlin 13.72 Gbps, and AutoMDT 16.92 Gbps, with 1.23× gain (Swargo et al., 7 Aug 2025). The abstract summarizes these results as “up to 8x faster convergence and a 68% reduction in transfer completion times compared with state-of-the-art solutions.”

This AutoMDT is therefore unrelated to medical decision-tree extraction except in acronym. Its technical center is modularization of a data path and closed-loop concurrency control under DRL.

6. Medical digital twins and the “AutoMDT vision”

The AADT paper uses Medical Digital Twins (MDTs) in a different sense and explicitly states that its framework “realizes the AutoMDT vision” (Chen et al., 28 Mar 2026). The setting is rare genetic disorders, where static or passively updated twins create a synchronization gap as phenotypes, genomic interpretations, and care guidelines evolve over time. The proposed system is an event-driven, layered architecture organized around the OpenClaw Agent Runtime, the AgentSkill system, a Data Ingestion & Normalization Layer, trigger-based analysis workflows, and a Digital Twin State Manager (Chen et al., 28 Mar 2026).

The Proactive Heartbeat Scheduler is a local daemon that wakes every $c:E\to C$2 hours, nominally 1 hour for phenotype and 24 hours for variants, scans local workspaces and remote APIs, and ensures no human prompt is required for periodic tasks. The AgentSkill System provides modular skills installed via ClawHub, including PhenoSkill for phenotype ingestion and ClinVar reinterpretation. The PhenoSnap Toolkit redacts PII, applies spaCy PhraseMatcher against a locally stored HPO ontology, performs negation detection via dependency parsing, and outputs timestamped Phenopacket-compliant JSON. The Variant Parser reads patient VCF, converts to SPDI notation, and queries NCBI E-utilities for ClinVar record IDs and significance. File-watch and heartbeat triggers invoke the State Manager, which merges JSON artifacts into a single RDMDT state and persists every version with an immutable timestamped event log (Chen et al., 28 Mar 2026).

The state update is formalized as

$c:E\to C$3

where $c:E\to C$4 are new Phenopacket records, $c:E\to C$5 new variant annotations, and $c:E\to C$6 new clinical record updates (Chen et al., 28 Mar 2026). Variant reinterpretation uses the rule

$c:E\to C$7

When the rule is satisfied, the system generates a structured alert and appends an updated variant summary to the workspace.

The prototype evaluation reports two rare-disease case studies. For phenotype tracking, data-ingestion latency is 10 minutes, diagnostic rank improves from 346 to 1, and the HPO-based ranking model’s AUC rises from 0.68 for static snapshots to 0.82 when run continuously. For variant reinterpretation, alert delivery time is approximately 1 hour after ClinVar release, contrasted with approximately 3 months for manual workflows, and the case-study table gives “8 months → 1 h” for time-to-alert reduction (Chen et al., 28 Mar 2026). Security and human-in-the-loop design are central: local-first deployment keeps PHI on institutional hardware, skills are least-privilege, PII is redacted before NLP processing, the LLM is used only for orchestration, prompt-injection defenses are applied, code is pinned to commits, event logs are immutable, and variant reclassification alerts require explicit clinician acknowledgement before any change in the patient chart (Chen et al., 28 Mar 2026).

This digital-twin usage is conceptually adjacent to the medical decision-tree usage in that both concern structured clinical decision support, but the technical object is different. Here the target is not a tree extracted from text; it is a continuously updated patient state assembled from phenotypic, genomic, and clinical artifacts.

7. Significance, boundaries, and recurrent misconceptions

Across the cited literature, AutoMDT does not denote a single canonical framework. In medical NLP, it refers to structured extraction of decision processes from text into trees, using either end-to-end LLM generation, pipeline decomposition, or parameter-efficient fine-tuning (Zhu et al., 2024, Li et al., 6 Oct 2025). In systems research, it refers to DRL-based control of modular data-transfer stages (Swargo et al., 7 Aug 2025). In rare-disease digital twins, it denotes a broader vision of proactive synchronization and auditable patient-state management (Chen et al., 28 Mar 2026).

A common misconception would be to treat these usages as interchangeable because they share the acronym MDT. The supplied sources do not support that reading. In one line, MDT means medical decision tree; in another, medical digital twin; in another, AutoMDT is not medical at all. A second misconception would be to infer a stable medical benchmark consensus from the Text2MDT paper alone. The supplied material contains both the abstract claim that sufficiently large end-to-end LLMs outperform pipeline methods and the detailed GPT2-medium result in which the pipeline is stronger; this suggests that model size and evaluation setup matter materially (Zhu et al., 2024). A third misconception would be to reduce the digital twin work to LLM-based extraction. The AADT design explicitly separates orchestration from clinical extraction, using deterministic code for normalization and state updates (Chen et al., 28 Mar 2026).

The most coherent encyclopedia-level interpretation is therefore plural rather than singular. AutoMDT names multiple contemporary attempts to automate structured decision or control processes under modular architectures: extraction of clinical decision trees from text, adaptive concurrency control in data transfer, and autonomous synchronization of medical digital twins. The term’s analytical value depends on preserving these distinctions.