Generative Simulation and Summarization of Neonatal Patient Data

Abstract

In the Neonatal Intensive Care Unit (NICU), clinicians must balance the demands of constant patient monitoring with the need for precise documentation and clear communication with colleagues and families. To address the clinical burden of documenting patient care and health status, this paper presents two complementary AI-based systems. First, a GAN-driven NICU Patient Simulator is developed to generate realistic neonatal vital sign data and discrete clinical intervention events, typical of care in the NICU. While useful for a variety of research goals, this simulator provides a safe and controllable data source essential for the development and validation of the second system: the LLM-powered Neonatal Patient Status Summarizer (NPSS). The NPSS fuses the output of multiple machine learning systems, each extracting specific aspects of patient care and health, together with vital sign data from a patient monitor. Leveraging Retrieval-Augmented Generation (RAG) to incorporate neonatal-specific reference data, the NPSS enables several key use cases, including generating parent-friendly updates, summarizing patient status for clinician handovers, and automatically populating patient records for charting. Simulator validation demonstrates the high fidelity of the simulated data relative to available infant data in Physionet. The NPSS is evaluated using an automated LLM-as-judge framework across repeated test scenarios. To mitigate self-preference bias, evaluations were conducted using three distinct LLM judges (OpenAI o3-mini, Llama-3, and Mistral). Across judges, the NPSS achieved consistently high relevance scores (0.95–0.99) and strong groundedness scores (0.80–0.91), indicating that generated summaries remain on-topic and faithful to the underlying simulator data. Once validated, the NPSS will reduce charting workload, improve shift handover efficiency, and streamline parental updates, addressing key clinical bottlenecks in NICU data workflows.

1. Introduction

The Neonatal Intensive Care Unit (NICU) is a high-stress, high-stakes environment requiring continuous monitoring; however, manual clinical documentation remains time-consuming, error-prone, and discontinuous. A growing suite of machine learning (ML) algorithms is being developed using video and other non-contact sensing modalities, capable of estimating patient vital signs [1,2], clinical scene segmentation [3], patient movement [4], clinical interventions [5], and also environmental/contextual factors (e.g., patient coverage, lighting level) [6]. While these tools provide a wealth of data, a new challenge arises: how can these multimodal data be fused, filtered, and distilled into summaries that are meaningful for human interpretation to ease the clinical documentation burden?

Early attempts to automate clinical summaries relied on report templates, which offered structure but lacked the natural language and flexibility required for diverse clinical use cases [6]. The recent emergence of Large Language Models (LLMs) presents a significant opportunity to generate more natural and context-aware text summaries that can be tailored to different audiences. Recent surveys have reviewed the application of LLMs for biomedical text summarization, charting their evolution and potential uses across the healthcare domain [7,8,9].

We here propose the Neonatal Patient Status Summarizer (NPSS), as conceptualized in Figure 1. Such a system would ingest data from myriad sources (e.g., patient monitors, ML algorithms) and generate tailored textual outputs for several critical use cases, such as automatically populating Electronic Health Record (EHR) charts, providing concise shift handover summaries for clinical teams, and delivering empathetic, understandable updates to parents.

However, developing and validating such a specialized LLM-based system for the NICU presents two fundamental challenges. First, training these models requires vast amounts of high-quality, domain-specific data, but access to sensitive neonatal patient data is rightly restricted. Second, for summaries to be clinically useful, the system must go beyond simply reporting data; it needs to interpret those data in the context of established clinical norms and in a way that is tailored for the specific user.

To address these challenges, we introduce an AI framework that differs from existing work, which has largely focused on summarizing static, text-only documents such as clinical notes or scientific literature [7,8,10], or capturing verbal interactions between clinicians and patients [11]. The novelty of our approach is fourfold. First, our work is specifically tailored to the unique environment of neonatal intensive care. Second, it features a multi-endpoint summarizer that generates distinct, audience-specific summaries for clinical handovers, automated charting, and parent-friendly updates. Third, where many emerging “AI Scribe” systems summarize spoken or written clinician-patient communications [11], the NPSS fuses data from multiple modalities and sources beyond text. Finally, our framework directly tackles the data scarcity issue by coupling the NPSS with a high-fidelity NICU Patient Simulator. By first generating realistic synthetic data, we are able to develop and validate a system capable of interpreting and summarizing dynamic patient status.

The first component of our framework is a NICU Patient Simulator that generates realistic vital sign data using Generative Adversarial Networks (GANs) [12,13] and also discrete intervention events. Most existing simulators either do not simulate interventions at all, or permit only operator-initiated simulated actions (e.g., neonatal resuscitation manikins) [14,15,16]. In contrast, our simulator employs a hybrid approach, using a GAN framework for continuous vital sign data and an independent Poisson-based multivariate point process to model discrete intervention events. We implement this event generator with a covariance structure that explicitly models the correlation between care events, with time of day, and with overall patient health, to better reflect realistic co-occurrence patterns in NICU practice [6]. This hybrid design enables the simulator to capture both the temporal dynamics of vital signs and the interdependency of discrete clinical actions, producing richer, practice-consistent training and evaluation data.

The second system is the NPSS itself, a suite of summarization tools built on a Retrieval-Augmented Generation (RAG) pipeline. The RAG architecture is essential because it dynamically grounds the LLM in factual, domain-specific knowledge. For any given prompt, it automatically retrieves the most relevant information from an external knowledge base, such as reference documents detailing healthy neonatal vital sign ranges [17], before generating a summary. This enables the NPSS to provide crucial context (e.g., flagging a vital sign as “elevated”) without hard-coding range information or risking ungrounded LLM “hallucinations”. Furthermore, by using specific prompt engineering for each target use case, this single pipeline is adapted to serve several key use cases: generating empathetic updates for parents, creating concise handovers for clinicians, and producing structured data for automated charting.

The primary contributions of this work are as follows:

• Development of a GAN-driven NICU patient simulator capable of producing realistic neonatal respiration rate (RR) and heart rate (HR) data, optionally with arrhythmia. The simulator also generates realistic clinical and routine care events, accounting for correlations between events. Together with user-entered patient post-conceptual age, sex, and weight, these data are exported as a JSON data structure suitable for ingestion by the NPSS.
• A modular LLM-based summarization pipeline (NPSS) is developed using RAG for clinical accuracy and contextual relevance across multiple use cases.
• Validation of the summarization tools using synthetic patient care and health status data generated by the simulator. Groundedness and relevance are measured using a LLM-as-a-judge approach, across three different judge LLM model architectures.
• Demonstration of practical NPSS use cases, including nurse-to-nurse handovers, automated charting, and real-time parental communication. User-specific language tone and technical detail are observed across each use case.

Ultimately, this work aims to alleviate the clinical documentation burden, improve communication, and enhance parental engagement in the NICU.

1.1. Background and Related Work

Modern NICUs are data-intensive environments, representing a unique intersection of high-frequency physiological monitoring, stringent documentation standards [18], and emotionally charged communication with parents. This vast data volume, coupled with the need for real-time decision-making, places a substantial cognitive and administrative load on clinical staff. Studies have shown that NICU nurses can spend upwards of half of their time on documentation-related duties, reducing time for direct patient care [11]. Current EHR systems provide centralized access to patient records but often lack intelligent summarization, prioritization, or context-aware filtering. As a result, interpreting patient status over time remains a cognitively demanding task, especially during handovers or emergency interventions [19,20].

While EHRs provide centralized data access, they often lack the intelligent summarization and context-aware filtering needed to quickly interpret patient status over time. To manage this data overload, various Clinical Decision Support Systems (CDSS) have been developed. In pediatric and neonatal intensive care, these systems often manifest as dashboards designed to improve situation awareness and resource management. For instance, researchers at Sainte Justine’s Children’s Hospital have explored dashboards for visualizing patient status across a pediatric intensive care unit to support resource management during pandemics [21] and systems to structure data for better decision-making in patient care [22]. Our work differs in its primary objective: not to create a dashboard for visual analysis, but to produce natural language text summaries of patient status and care, driven by data from ML subsystems and patient monitors, suitable for diverse communication endpoints, including clinician handovers, automated charting, and parental updates.

Simulated patient data are essential for medical education, clinical testing, and AI system validation. Many existing neonatal simulators focus on procedural and resuscitation training through physical manikins. For example, the NeoNatalie Live manikin is used for ventilation-focused training, providing data-driven feedback on clinical skills [14], while other high-fidelity manikins allow teams to practice hands-on interventions for various neonatal conditions [15,16]. Beyond these physical models, several digital simulators are also available, such as ResusMonitor for real-time vital sign display [23], and Body Interact and Shadow Health patient simulators for scenario-based clinical reasoning [24,25]. Our approach differs fundamentally in its goal: to create a generative NICU patient simulator capable of producing realistic, multi-day streams of vital sign and intervention data, specifically for the purpose of developing and testing the NPSS.

To create the rich time-series vital sign data needed for our summarizer, we turned to generative models [26,27]. A Generative Adversarial Network (GAN) consists of two neural networks—a generator and a discriminator—that are trained simultaneously in an adversarial process [12]. The generator creates synthetic data samples, while the discriminator’s objective is to distinguish these synthetic samples from real data. Through these competitive training objectives, the generator learns to produce data that are indistinguishable from the real data on which it was trained [12]. Originally trained for image generation, GANs have been developed for multivariate time series generation [13], and specifically for (adult) vital sign generation [27].

We are not aware of any publicly available neonatal dataset that provides continuous, long-term vital sign information along with diagnoses and annotated clinical intervention events. Existing datasets tend to provide only short recordings of patient vital signs and, importantly, often explicitly avoid any time period during which critical care interventions or routine care are being administered, since this would complicate vital sign estimation systems. In fact, this lack of complex patient data motivated our creation of the neonatal patient simulator: we wish to create input data for developing and evaluating the NPSS, along with gold standard annotations of what actually transpired during the 8-h period to be summarized.

Recent advances in LLMs have enabled the generation of realistic clinical text, offering potential for automating healthcare documentation [11]. However, ensuring factual accuracy remains a significant hurdle. LLMs can “hallucinate,” producing plausible yet incorrect information, a risk that is unacceptable in safety-critical applications, such as neonatal care [28].

To address this, many systems now use RAG, which enhances LLMs by grounding generation in external, domain-specific knowledge sources. RAG was formalized by Lewis et al. as an approach that combines pretrained generative models with dense retrieval mechanisms for more factual and contextually grounded outputs [29]. In healthcare-specific contexts, Neha et al. identify EHR summarization as a prevalent application, highlighting RAG’s potential to leverage curated knowledge to reduce hallucination risks while minimizing omissions and clinical inaccuracies in discharge notes and patient records [30].

RAG can retrieve pre-encoded, relevant reference knowledge from the vector store, and embed that knowledge into the system prompt before any text is generated. In our work, we adopt a similar architecture to ensure that summaries referencing neonatal vital signs are grounded in clinically validated norms (see Section 2).

Research Gaps Motivating This Study

The current state-of-the-art presents a clear opportunity and a distinct gap. On one hand, AI Scribe initiatives are emerging to automate the summarization of spoken clinical interactions, with several reviews highlighting progress in speech-to-text documentation and ambient clinical intelligence [11]. AI Scribes are seeing rapid adoption, with one 2025 study reporting 15,791 h of documentation time saved across 2.5 million doctor-patient encounters through the adoption of AI Scribe technology, while both doctors and patients reported more positive interactions [31]. In parallel, a suite of machine learning algorithms can now predict numerous aspects of patient status (vital signs, interventions, patient segmentation, environmental variables, etc.) from sensor data. A framework for summarizing these diverse, multimodal data streams into coherent text summaries suitable for different audiences (parents, nurses, EHRs) is notably absent. Furthermore, no extant patient simulator is capable of generating the realistic, temporally-rich neonatal vital sign and discrete event data required to rigorously develop and validate such a summarization system. This work addresses these specific gaps by creating a modular framework where a high-fidelity GAN-based simulator produces the necessary data to develop and validate a multi-purpose, RAG-enhanced LLM patient status summarization pipeline.

2. Materials and Methods

This section outlines the methodologies employed in the design and development of the two core components of this research: the NICU Patient Simulator and the NPSS. These systems were developed as distinct modules, with the simulator providing a robust platform for generating realistic neonatal data, which subsequently serves as input for the development and validation of the LLM-based NPSS.

2.1. NICU Patient Simulator Development

The NICU Patient Simulator was engineered to generate synthetic, temporally coherent neonatal patient data, simulating an 8-h clinical shift with data points at 5-min intervals. The development focused on realistic vital sign generation and discrete intervention event modeling.

2.1.1. GAN Architecture and Training

The simulator uses separate, dedicated GANs to generate realistic time series of (i) healthy RR, (ii) healthy HR, and (iii) arrhythmia HR episodes (bradycardia and tachycardia). This modular approach to HR simulation was chosen because the modeling requirements for normal vital signs are fundamentally different from those for pathological cardiac events. The baseline GAN produces a continuous, stochastic baseline signal exhibiting typical mean and variance for the entire simulated period. The pathological GAN simulates episodic periods of bradycardia and tachycardia behavior, with abrupt deviations characteristic of these events (e.g., HR dropping to 50–90 bpm for bradycardia, rising to 140–210 bpm for tachycardia [32]). When a pathological condition is selected, the specific GAN generator for that disease state is activated to directly generate the corresponding pathological vital sign time series.

The baseline GAN generator uses a simple feedforward network with an input layer of 10 nodes (the random noise vector), followed by a hidden layer of 64 nodes, and a second hidden layer of 32 nodes, before outputting a single vital sign value (1 node). The full architecture is: Linear($10\to 64$) → ReLU → BatchNorm → Linear($64\to 32$) → ReLU → Linear($32\to 1$) → Sigmoid.

The pathological GAN (used for Bradycardia and Tachycardia) is both deeper and wider. It begins with an input layer of 10 nodes and uses successive hidden layers of 128 nodes, 256 nodes, and 96 nodes, respectively. The full architecture is: Linear($10\to 128$) → ReLU → Linear($128\to 256$) → ReLU → Linear($256\to 96$) → ReLU → Linear($96\to 1$) → Sigmoid. The increased capacity of this network is required to model the complex, non-periodic patterns of arrhythmia.

The discriminator architecture for both GANs is an MLP structured to receive a single vital sign sample and output a probability score [33]. The model takes a single value (size 1) as input, followed by hidden layers of 32 nodes and 16 nodes, before outputting a single scalar value (size 1) representing the probability of the input being a real sample. The architecture is: Linear($1\to 32$) → ReLU → Linear($32\to 16$) → ReLU → Linear($16\to 1$) → Sigmoid.

For both the baseline and pathological models, the generator receives a 10-node random noise vector and outputs a single, denormalized vital sign value (e.g., one HR sample). As the architecture is a non-recurrent MLP, the generation of a time series (e.g., 5 min of data) requires running the generator multiple independent times to produce one sample every second. Each output sample is therefore statistically independent of the previous one, meaning the model captures the marginal distribution of the vital signs but not the temporal dynamics (i.e., the smooth progression of the time series). To enhance clinical realism, all generated time-series vital sign data underwent light smoothing using a Gaussian filter ($\sigma =2$) to eliminate physiologically implausible, high-frequency fluctuations.

2.1.2. Data Sources and Preprocessing for GAN Training

The MLP-GANs [33] used for “healthy” vital sign synthesis were trained using data from the “Preterm Infant Cardio-Respiratory Signals Database” on PhysioNet [34]. Due to the scarcity of neonatal arrhythmia data, adult bradycardia and tachycardia GAN training data were sourced for the “arrhythmia” GANs from the “Model for Simulating ECG and PPG Signals with Arrhythmia Episodes” dataset [35]. It is important to note that training the arryhthmia GANs using this use of adapted adult data represents a methodological limitation, as the underlying physiological patterns of arrhythmia may differ between adults and neonates [36].

To adapt the adult arrhythmia data for neonatal physiology, a normalization and scaling method was employed. The adult beats-per-minute (BPM) sequences were first normalized to a [0, 1] range using min-max normalization. Following GAN training, the synthetic data were denormalized to physiologically relevant neonatal ranges, as follows. For baseline HR and RR, data were normalized and then mean-shifted to a healthy range (110–150 BPM [32] and 30–100 breaths/min, respectively). For the bradycardia model, the generated HR data were scaled to a target range of 50–90 BPM [37], while for the tachycardia model, the data were scaled to 140–210 BPM [38]. This process ensured that the temporal patterns learned from the adult arrhythmia data were preserved while adapting the absolute HR values to reflect neonatal cardiac events.

All models were trained using Binary Cross-Entropy (BCE) loss and the Adam optimizer, with a learning rate of 0.0002 and a batch size of 16. The healthy HR/RR and Tachycardia/Bradycardia generators were trained for 5000 epochs.

2.1.3. Intervention Modeling

The simulator models both scheduled and unscheduled interventions to reflect the complexities of NICU care. Scheduled interventions are those that are pre-planned and occur at set times, such as medication administration, feeding, and routine patient assessments. Unscheduled interventions, in contrast, are reactive events that are initiated by a change in the patient’s condition, such as administering oxygen in response to a desaturation event.

The occurrence of unscheduled interventions is governed by a multivariate Poisson process [39], where the probability of an event k, $P\left(k\right)$, is based on the rate of occurrence, $\lambda$. A separate average rate (${\lambda }_i$) is dynamically computed for each distinct type of unscheduled intervention. The probability of any specific intervention occurring by a given time t is calculated based on its respective rate: $P_t=1-e^{-\lambda t}$. This was implemented using numpy’s random.poisson(rate) where rate represents the average number of events in a given interval.

These rates are dynamically adjusted based on the time of day to reflect clinical workflows, such as reducing non-essential interventions at night. Interventions are modeled as instantaneous, discrete events marked by a single time stamp, meaning interventions do not have explicit durations.

Some clinical interventions increase the likelihood of other interventions, such as the clinical practice of “bundle care,” where multiple interventions are performed during a single patient interaction to minimize sleep disruptions. The need to model dependencies (covariance) between multiple count-based events derived from a Poisson framework is a common problem in statistical modeling [40]. To capture such relationships, the simulator models the likelihood of co-occurring events using a covariance matrix, Figure 2, that defines the probability of one intervention type occurring, given another. Mathematically, the covariance matrix provides a set of scaling factors used to compute the instantaneous rate ${\lambda }_i\left(t\right)$ for any intervention i, making the process conditional on all other interventions active at time t. The adjusted rate is calculated as:

$${\lambda }_i\left(t\right)={\lambda }_{\mathrm{base},i}\times F_{\mathrm{Time}}\left(t\right)\times max\left[0,\left(1+\sum _{j\ne i}{\mathrm{Cov}}_{ij}·I_j\left(t\right)\right)\right]$$

(1)

where ${\lambda }_{\mathrm{base},i}$ is the base rate, $F_{\mathrm{Time}}\left(t\right)$ is the time-of-day scaling factor, ${\mathrm{Cov}}_{ij}$ is the covariance value between intervention i and j, and $I_j\left(t\right)$ is an indicator function (1 if intervention j is active, 0 otherwise) [39]. This approach allows the model to capture event dependencies: if a positive correlation (${\mathrm{Cov}}_{ij}>0$) exists between Intervention A and active Intervention B, the base rate ${\lambda }_A$ is temporarily increased. Conversely, negative correlations (${\mathrm{Cov}}_{ij}<0$) are used to model inhibited concurrent events. These covariance values were established based on clinical practice literature to reflect common care routines [41]. For example, a high correlation exists between “lighting adjustment” and “family visitation” to reflect that lights are often turned up when family is present, whereas a negative correlation was used for invasive interventions (e.g., imaging) to reflect their unlikely occurrence during a family visit. This system is designed to be configurable to match the specific policies and procedures of a given NICU.

Ultimately, the simulator outputs a structured JSON file for each simulated 8-h patient shift. Each JSON entry corresponds to a 5-min interval, containing a timestamp, vital signs (HR, RR, temperature; at 1 Hz), user-entered clinical data (post-conceptual age, sex, weight), and any interventions occurring during that 5-min interval.

2.2. Text Summarization Pipeline

The NPSS was developed to process patient data into summaries tailored for nurses and parents. In an actual deployment, the input data would come from a combination of patient monitoring sensors and ML-based predictions. For the purpose of developing and validating the NPSS, data were sourced from our Patient Simulator. The system leverages LLMs within a RAG framework, developed using LangChain [42], to enhance factual grounding and mitigate hallucinations.

The fundamental RAG pipeline, depicted in Figure 3, orchestrates the generation of context-aware summaries using several modules from LangChain. The process begins when a user input prompt is received. This input triggers the Memory-Augmented Conversational RAG chain, which manages the entire workflow. The chain first engages the Chat History Manager to pull the relevant conversation history from the Chat History Database. Concurrently, a Context Aggregator initiates the retrieval of information from two distinct vectorized sources: one containing the patient’s clinical data and the other containing external reference documents defining normative vital signs.

The retrieved patient data, the vital sign context, and the chat history are then consolidated in the Combine and Fill System Prompt step. This step dynamically populates a structured prompt template with all necessary information. The complete prompt is then passed to the LLM QA Execution stage, where the language model (OpenAI’s o3-mini) processes the context-rich input and generates a response. This response is finalized and, in a critical feedback loop, saved to the Chat History Database to maintain memory for subsequent interactions. Finally, the answer is returned to the user. This architecture ensures that each response is grounded in both the specific patient’s data and broader clinical knowledge while maintaining conversational coherence.

Patient data, structured as JSON files, are ingested using LangChain’s JSONLoader. The data is then segmented into semantically coherent chunks using a RecursiveCharacterTextSplitter, with an empirically determined optimal chunk size of 5000 characters.

2.2.1. Embedding & Retrieval

Textual chunks are converted into vector embeddings using OpenAI’s text-embedding-ada-002 model and stored in an InMemoryVectorStore. To address the distinct structural differences between the source data streams (i.e., JSON patient data vs. textual reference data), we implemented a dual-retrieval strategy with hyperparameters tailored to each. Retrieval was performed using cosine similarity without an additional reranking step.

The first retrieval pathway, managed by a History-Aware Retriever, handles patient data. For this data source, maintaining temporal context was critical for identifying trends over the 8-h shift. Consequently, we utilized a large chunk size of 5000 characters with a 200-character overlap (using LangChain’s RecursiveCharacterTextSplitter [43]) and retrieved the top-5 ($k=5$) most relevant chunks. This ensures the LLM has access to a comprehensive, temporally coherent view of the patient’s recent history.

The second retrieval pathway fetches relevant excerpts from reference material [17]. This domain required high-precision lookup of specific facts, such as normative vital sign ranges. For this index, we employed a much smaller chunk size of 250 characters with no overlap and a retrieval limit of $k=1$. This granular chunking strategy minimizes noise, ensuring that the retrieved context is strictly limited to the specific clinical definition or threshold requested by the query, thereby reducing the risk of hallucinations derived from irrelevant adjacent text. Retrieved information from both sources is then supplied to the LLM.

While the pipeline is designed to accommodate various pre-trained models (including open-source alternatives), o3-mini was used for this implementation, primarily due to its strong ability to follow instructions provided in a system prompt. The retrieval hyperparmeters for the NPSS are detailed in

Table 1. Retrieval hyperparameters for the dual-retriever architecture used in NPSS.

Parameter	Patient Data Retriever	Reference Material Retriever
Chunking Strategy	RecursiveCharacterTextSplitter	RecursiveCharacterTextSplitter
Chunk Size	5000 characters	250 characters
Chunk Overlap	200 characters	0 characters
Retrieval Method	Cosine Similarity	Cosine Similarity
Top-k	5	1
Embedding Model	text-embedding-ada-002	text-embedding-ada-002
Vector Store	InMemoryVectorStore	InMemoryVectorStore
Reranking	None	None

.

2.2.2. Prompt Engineering & Summarization Modules

Custom system prompts were engineered to guide the LLM’s behavior for each specific use case, resulting in four distinct modules tailored to different clinical needs. For parent-facing updates, the Parent Update Tool generates empathetic and simplified patient updates. Its system prompt explicitly instructs the LLM to “provide a compassionate update … clear, reassuring, and easily understandable by non-medical individuals”. In this way, the model is guided to avoid clinical jargon. This tool produces draft messages that would be vetted by a clinician prior to releasing the response to the parent.

In contrast, for the modules intended for clinical staff, including the Nurse Shift Summarizer and the Interactive Nurse Chatbot tool, the system prompt is designed for technical precision, instructing the model to “Provide the incoming nurse with all pertinent information … in a concise, technical summary”. The LLM was directed to use clinical terminology, such as “bradycardia” or “tachypnea”, when patient vitals fall outside the retrieved normative ranges. The Interactive Nurse Chatbot tool leverages conversational history to allow for iterative querying on specific events or trends.

Finally, the Auto-Charter module is designed for documentation of patient care and status in an EHR; its prompt uniquely instructs the LLM to generate a structured JSON report, enforcing adherence to clinical terminology and precise categorization of abnormalities. The prompt specifies a detailed sample JSON schema with fields like “Associated_symptoms,” “Interventions,” and “Progress_notes,” and commands the model to produce “no commentary, diagnosis, or extra text—only the JSON object”. This structured output is suitable for automatically populating an entry in an EHR system, following human verification.

This role-specific prompting ensures that, for parent updates, the model emphasizes empathy and plain language, while for clinical handovers and charting, it prioritizes concise technical language and structured reporting.

2.3. Experimental Validation

A comprehensive validation protocol was established to assess the functionality, reliability, and clinical alignment of both the NICU Patient Simulator and the NPSS. The validation for each system focused on distinct criteria appropriate to its intended function, with the simulator’s realism being vital for its role in downstream summarizer testing, and the summarizers being evaluated for accuracy, coherence, and domain appropriateness.

2.3.1. Simulator Evaluation Methodology

The NICU Patient Simulator’s outputs were evaluated for physiological realism and temporal coherence against real-world neonatal data sourced from the previously mentioned PhysioNet databases [34,35]. The primary objective was to ensure that the synthetic data, representing an 8-h NICU shift, was clinically realistic and suitable for subsequent use in validating the summarization tools. Validation was performed across several categories of generated vital signs: normal HR, normal RR, tachycardia episodes, and bradycardia episodes.

Distributional Similarity Metrics

To quantify the similarity between the distributions of synthetic and real vital sign data, two primary statistical tests were employed. These metrics were chosen to provide a comprehensive comparison of both the shape and distance between the data distributions. First, the Kolmogorov-Smirnov (KS) Test, a non-parametric test, was used to compare the empirical cumulative distribution functions (ECDFs) of the synthetic HR and RR data against reference Physionet datasets. The KS test assesses whether two samples are likely drawn from the same underlying distribution; a higher p-value indicates a lack of statistically significant difference [44]. Additionally, the Wasserstein Distance, also known as the Earth Mover’s Distance, was used to quantify the minimum “cost” required to transform one probability distribution into another. A lower Wasserstein distance signifies a closer alignment between the synthetic and reference distributions, providing an intuitive measure of similarity [45].

Summary Statistics

Standard descriptive statistics were calculated for both synthetic and reference datasets to compare their central tendency, dispersion, and shape. These included the mean and standard deviation (STD) to ensure that synthetic vital signs fell within expected physiological ranges and exhibited comparable variability to real data. Furthermore, skewness and kurtosis were used to assess the asymmetry and the “tailedness” (propensity for extreme values) of the data distributions, respectively, providing insights into the shape of the generated data compared to references.

Arrhythmia Simulation

The simulator’s ability to replicate cardiac arrhythmia, namely tachycardia and bradycardia, was assessed by examining these episodic events from the generated data. For these episodes, the following characteristics were compared against reference data: the total count of episodes, the mean duration of episodes in timesteps (calculated as the average across all extracted episodes), and the mean maximum BPM (for tachycardia) or mean minimum BPM (for bradycardia) (also averaged across all extracted episodes). Distributional similarity for episode duration and max/min BPM was also assessed using the KS test.

2.3.2. NPSS Validation Framework

The NPSS was evaluated using a structured, automated multi-judge validation framework designed to assess clinical relevance and factual faithfulness of generated summaries. Because all NPSS tools (i.e., the Parent Update Tool, Nurse Shift Summarizer, Interactive Nurse Chatbot, and Auto-Charter) share the same underlying RAG architecture, validation was conducted using the Interactive Nurse Chatbot interface as a representative implementation.

A total of 60 test runs were performed; 10 repetitions of six prompt-based experiment types: (1) generating a full 8-h handover summary; (2) listing all bradycardia episodes; (3) listing all tachycardia episodes; (4) identifying respiratory abnormalities; (5) constructing an intervention timeline; and (6) evaluating vital sign trends against established neonatal reference ranges [17].

Each experiment type was validated against simulator-generated ground truth data to ensure objective assessment.

Automated evaluation was implemented using the LangSmith platform. Rather than employing traditional string-matching evaluators (e.g., QAEvaluator), which are unsuitable for free-form clinical summarization tasks, the evaluation prioritized semantic alignment and factual consistency.

Two custom evaluators were defined under an LLM-as-judge paradigm [46,47], wherein an auxiliary LLM independently scores the NPSS output according to predefined criteria: Relevance, which quantifies the degree to which the generated response directly addresses the clinical prompt and remains focused on the requested task, and Groundedness, which quantifies the extent to which statements in the generated summary are factually supported by retrieved source context. For each test run, all RAG-retrieved context—including both simulated patient data and external neonatal reference material [17]—was programmatically aggregated and provided to the judge model. This metric serves as a structured assessment of factual faithfulness and hallucination risk.

3. Results

This section presents the quantitative findings from the validation of the NICU Patient Simulator and the NPSS, as outlined in the Experiment Validation methodology.

3.1. NICU Patient Simulator Results

The simulator’s performance was evaluated based on its ability to generate realistic vital signs for normal neonatal physiology and specific pathological conditions. The results are derived from an 8-h simulation for each physiological state (normal, tachycardia, bradycardia, etc.).

3.1.1. Synthetic Vital Sign Realism

The synthetic vital sign data for normal HR and RR were compared against reference neonatal data [34] using distributional similarity metrics and summary statistics.

As shown in

Table 2. Validation metrics for normal heart rate.

Metric	Real Data	Synthetic Data
Mean (BPM)	128.4	127.0
Standard deviation (STD)	12.7	13.5
Skewness	0.12	0.15
Kurtosis	2.85	3.10
KS statistic/p-value/WD	0.085/0.320/2.30

, the synthetic HR data closely matched the reference data. The mean HR was 128.4 BPM (real) versus 127.0 BPM (synthetic), with standard deviations of 12.7 and 13.5, respectively. The Kolmogorov-Smirnov (KS) test yielded a p-value of 0.320, and the Wasserstein distance was 2.30, indicating no statistically significant difference between the distributions and a close alignment. Skewness (0.15 vs. 0.12) and kurtosis (3.10 vs. 2.85) were also comparable. Ideally, we would expect a KS statistic near zero, a KS p-value approaching 1, and a Wasserstein distance close to zero, which would indicate that the real and synthetic distributions are nearly indistinguishable. While our observed p-value is not close to 1, it is well above the conventional threshold of 0.05, meaning we cannot reject the null hypothesis that the real and synthetic data are derived from the same distribution. In practical terms, this implies that the small differences observed may be explained by random variation rather than a systematic difference in the underlying distributional shape. This close statistical alignment is visually confirmed in Figure 4, which plots the synthetic and real time-series data directly.

Similarly, as shown in

Table 3. Validation metrics for respiration rate.

Metric	Real Data	Synthetic Data
Mean (BPM)	127.26	126.86
Standard deviation (STD)	10.81	12.29
Skewness	0.23	$-0.50$
Kurtosis	$-0.09$	$-1.05$
KS statistic/p-value/WD	0.168/0.118/3.761

, synthetic RR data demonstrated high fidelity. This is visually confirmed in Figure 5, which plots the synthetic and real time-series data directly.

3.1.2. Simulation of Arrhythmia

The simulator’s capability to generate realistic arrhythmia was evaluated using both tachycardia and bradycardia episodes. Validation compared the frequency, duration, and range of episodes between real and synthetic data. Over the 8-h observation period, the synthetic model generated 59 tachycardia episodes compared to 57 in the reference data (7.38 vs. 7.13 episodes/h) (

Table 4. Validation metrics for tachycardia episodes.

Metric	Real Data	Synthetic Data
Count of episodes (8 h)	57	59
Frequency (episodes/h)	7.13	7.38
Mean duration (timesteps)	15.77	15.85
Mean maximum BPM	213.59	213.15
KS statistic/p-value (duration)	0.081/0.785
KS statistic/p-value (max BPM)	0.093/0.682

). The mean tachycardia episode duration was 15.85 time steps (synthetic) versus 15.77 (real), while the mean maximum BPM was 213.15 (synthetic) versus 213.59 (real). KS tests for episode duration ($p=0.7850$) and maximum BPM ($p=0.6822$) indicated strong alignment between real and synthetic distributions.

For bradycardia, the model generated 45 episodes compared to 42 in the simulated patient data (5.63 vs. 5.25 episodes/h) (

Table 5. Validation metrics for bradycardia episodes.

Metric	Real Data	Synthetic Data
Count of episodes (8 h)	42	45
Frequency (episodes/h)	5.25	5.63
Mean duration (timesteps)	10.20	10.60
Mean minimum BPM	78.40	77.90
KS statistic/p-value (duration)	0.094/0.713
KS statistic/p-value (min BPM)	0.089/0.653

). The mean episode duration was 10.6 time steps (synthetic) versus 10.2 (real), and the mean minimum BPM was 77.9 versus 78.4. KS tests for episode duration ($p=0.7125$) and minimum BPM ($p=0.6534$) further confirmed no significant statistical difference between distributions.

3.2. NPSS Results

The NPSS was evaluated for its ability to generate accurate, audience-specific summaries from synthetic NICU patient data. Using the Interactive Nurse Chatbot interface, simulated patient profiles were generated for each test case, producing structured JSON files containing vital signs and clinical events across an 8-h shift. The NPSS was prompted to summarize these cases, and outputs were compared against simulator-derived ground truth data.

Across all test runs, the NPSS achieved consistently high Relevance scores ($0.95$–$0.99$), indicating that the generated summaries reliably captured the clinically salient aspects of each scenario and remained focused on the user’s informational needs. Groundedness scores ranged from $0.80$ to $0.91$, reflecting strong factual alignment between the generated summaries and the underlying simulator data. Given the complexity of summarizing clinical information into free-form natural language, these scores indicate a high level of faithfulness and a low propensity for unsupported content. Collectively, these results indicate that the NPSS produces summaries that are both on-topic and largely faithful to simulator ground truth, warranting further examination of judge-specific scoring behavior. The distribution of groundedness scores across judges is illustrated in Figure 6, highlighting both central tendency and variability in scoring behavior.

Visual inspection of Figure 6 reveals distinct scoring behaviors across judges. Llama-3 exhibits the narrowest interquartile range and the smallest standard error (

Table 6. Average evaluation scores (mean ± standard error) for different LLM judge models.

Judge Model	Groundedness	Relevance
o3-mini	$0.91\pm 0.024$	$0.99\pm 0.006$
Llama3	$0.80\pm 0.002$	$0.97\pm 0.009$
Mistral	$0.82\pm 0.017$	$0.95\pm 0.020$

), indicating highly consistent scoring across runs. Mistral demonstrates greater dispersion, as reflected by both a wider interquartile range and a larger standard error ($\pm 0.017$). The o3-mini judge displays the highest median groundedness score overall but also the largest variability ($\pm 0.024$), including several lower outlier values. This pattern suggests a generally higher self-assessment tendency accompanied by occasional stricter evaluations in specific cases.

Furthermore, to assess the reliability of these generative metrics and mitigate potential self-preference bias, we compared the evaluation scores across three distinct LLM judges: the generator model itself (o3-mini) and two independent models (Llama-3 and Mistral). As summarized in Table 6, we observed a statistically significant effect of judge model choice on groundedness scores. Specifically, the o3-mini judge assigned higher groundedness scores ($0.91\pm 0.024$) to its own generated summaries compared to the external judges ($0.80$ and $0.82$, respectively). This indicates that groundedness evaluations are sensitive to judge model selection, whereas relevance remains comparatively robust across architectures.

Relevance scores exhibited no statistically significant difference across judges, reinforcing the stability of topical alignment assessment across model families.

A key capability of the NPSS is its use of prompt engineering to tailor outputs for different audiences. Figure 7 shows two examples of generated text from the same simulated patient, demonstrating the contrast between a technical summary for a nurse and an empathetic update for a parent. Of course, any generated text would have to be vetted by clinical staff before being released to a parent or included in an EHR.

3.3. Ablation Study: Impact of RAG

To quantify the incremental value of the RAG architecture and address the necessity of external clinical knowledge, we conducted an ablation study comparing the full NPSS against a non-RAG baseline. In this configuration, the LLM was provided with a simulated patient’s raw vital sign data (JSON) but was denied access to the external reference material. The simulated case represented a preterm neonate with bradycardia episodes.

We performed 30 test runs focused on clinical validity: 20 runs specifically targeting the identification of bradycardia episodes and 10 runs generating general patient summaries for the nurse summary use case. The non-RAG baseline demonstrated a critical failure in clinical reasoning. Without access to the specific neonatal reference standards [17], the model hallucinated incorrect vital sign thresholds, thereby failing to identify any of the true bradycardia episodes. Without access to the neonatal-specific reference material, the NPSS instead frequently cited a generic heart rate threshold of 100 bpm.

In regard to the generated summaries, the non-RAG baseline accurately described “fluctuations” in the HR and RR data but failed to interpret them as pathological events. Confirming that, while the LLM possesses general medical knowledge, the retrieval of specific, authoritative context—such as the breakdown of normal vital signs by age group provided in [17]—is essential for accurate clinical decision support in the NICU.

3.4. Compute Resources Used in This Study

The simulator GAN models were trained using an NVIDIA 3090 GPU server. Since inference is far less computationally demanding than training, once trained, the simulator can generate new patient vital sign (HR, RR) and discrete clinical intervention event data with very basic hardware. However, the same 3090 GPU server was used to generate all simulated patient data. The NPSS leverages OpenAI LLMs (GPT4 was investigated, but ultimately o3-mini was used since it better adhered to instructions). These OpenAI models are run through an API (i.e., the model itself runs on an OpenAI cloud server). The o3-mini LLM took approximately 5–10 s to generate text summaries for each use case (parent update, nurse handover, etc.) when given eight hours of simulated patient vital sign and intervention data; it used an approximately equal time to judge the generated text. Local LLMs (LLAMA and Mistral) were investigated as alternative LLM-as-a-judge models. These models ran locally on a server with an NVIDIA 5080 GPU with 16 GB VRAM. These models take only a few seconds to judge a summary generated by o3-mini.

4. Discussion

This study successfully developed and validated two complementary AI-driven systems aimed at addressing critical challenges in NICU data management and communication: a GAN-based NICU Patient Simulator and a suite of RAG-based LLM Patient Status Summarization tools. The results indicate strong potential for these systems to enhance clinical workflows, improve data realism for research and training, and facilitate better communication with parents.

The NICU Patient Simulator demonstrated a fair degree of realism in generating synthetic neonatal vital signs, including normal physiological patterns and specific pathological episodes. The efficacy of the GANs in capturing complex physiological dynamics (i.e., periods of arrhythmia) is supported by statistical validation. For instance, the models for normal heart rate and bradycardia episodes showed strong alignment with reference data, supported by KS-test p-values of 0.320 and 0.7125, respectively. The Wasserstein distance for normal heart rate was 2.30, a value indicating close distributional similarity in the context of physiological signals that vary over a wide range. The model for tachycardia also showed strong alignment with reference data (KS test p-value of 0.7850), confirming the simulator’s ability to replicate the complex, non-linear patterns of this condition. However, it is noted that the simulator does not currently account for ongoing and evolving diagnoses nor does vital sign data respond to simulated clinical interventions.

Ensuring stable and physiologically plausible GAN outputs required careful preprocessing of source data, including scaling of adult arrhythmia data, and iterative tuning of GAN architectures. While Gaussian smoothing mitigated some artifacts, the vital sign data generated by the GAN model within the neonatal patient simulator may not exhibit temporal coherence beyond aggregate statistics (e.g., mean, variance, skew, kurtosis, and other distribution-level metrics). For the arrhythmia cases, we have shown that the frequency and duration of simulated episodes closely matched the reference data, indicating that the simulated vital sign data exhibit temporal realism (to a point). While the simulator was sufficient for the purpose of developing the NPSS, greater temporal coherence may be required for other downstream uses of the neonatal patient simulator. In that case, temporal metrics, such as RMSE of derivatives, should be measured to ensure event transition realism. Furthermore, the current simulator focuses on a core set of vital signs; expanding this to include additional parameters, such as SpO₂ and blood pressure, will increase its comprehensiveness. Moving to a multivariate GAN would better capture complex relationships between individual vital signs.

The RAG-based LLM summarization pipeline showed promising results in generating accurate and relevant clinical summaries. The high Groundedness (0.91) and Relevance (0.99) scores for the Interactive Nurse Chatbot (Table 6) indicate that the system can reliably extract and present information pertinent to user queries, adhering closely to the source data [48]. The strong Recall score (0.91) further suggests that critical clinical details are unlikely to be omitted.

The development of distinct summarizer modules (Parent Update Tool, Nurse Shift Summarizer, Interactive Nurse Chatbot, Auto-Charter) tailored to specific end-users is a significant strength. This customization, primarily achieved through meticulous prompt engineering and output structuring, allows the system to address diverse communication needs—from empathetic, simplified updates for parents to concise, technical shift summaries for nurse handovers, and structured data for EHRs. The modules were designed to achieve high usability and appropriateness of tone, an objective that will be formally assessed in future work.

Despite the strong quantitative performance observed across automated evaluation metrics, the summarization system is not without limitations. Although groundedness scores were consistently high (0.80–0.91 across judges), the variation observed between LLM evaluators highlights the inherent subjectivity of generative model assessment. In particular, differences in groundedness scoring across judges suggest that factual faithfulness evaluations may be sensitive to the choice of evaluation model. While relevance scores remained uniformly high (0.95–0.99), indicating reliable topical alignment with clinical prompts, groundedness remains the more stringent and variable metric.

Importantly, the evaluation framework itself relies on an LLM-as-judge paradigm, which, although widely adopted [46,47], is not equivalent to formal clinical validation. While groundedness scoring serves as a structured proxy for hallucination risk and factual consistency, it does not eliminate the need for future validation against real-world clinical documentation workflows. Further research into enhanced retrieval strategies, tighter grounding constraints, and potential post-generation verification mechanisms may help further reduce the risk of unsupported statements in high-stakes medical contexts [49].

4.1. Clinical Implications & Contributions

The decoupled nature of the simulator and summarizer offers distinct advantages. The neonatal patient simulator provides a valuable tool for validating not only our summarization pipeline but potentially other AI-driven healthcare applications, reducing reliance on sensitive real patient data for initial development. Conversely, the NPSS, can and should be validated on actual patient data and clinician-generated gold-standard summary text before any clinical deployment.

This work contributes to the growing body of research on generative AI in healthcare. While prior work demonstrated proof-of-concept summarization from static, single-point-in-time data [6], our NICU Patient Simulator generates continuous HR and RR data streams over entire shifts. This enables temporally-aware and role-specific text summarization [50,51]. Automated charting could reduce documentation errors, while streamlined handover summaries could enhance patient safety by ensuring consistent and accurate information transfer. The Parent Update Tool addresses an important, often overlooked, aspect of NICU care: providing timely, understandable, and empathetic communication to families during a stressful period.

4.2. Limitations of the Study

A formal evaluation of the NPSS to assess factors such as accuracy, clarity, and tone, has not yet been formally conducted with end-users; this is a critical next step. The simulator, while validated against real data, represents a proof-of-concept model, currently only simulating arrhythmia and not other disease states. Furthermore, it does not include diagnoses that are expected to evolve over the course of a patient’s stay in the NICU, nor does it respond to clinical interventions. The simulator is currently trained on short-period data from Physionet; transitioning to long-term neonatal patient monitoring data will lead to increased realism as such data become available. The NPSS was developed and validated using synthetic data; transitioning to real-world EHR data will introduce challenges such as handling missing data and adapting to site-specific documentation practices [50]. Finally, the ethical implications of deploying LLMs for clinical documentation and communication require ongoing consideration, particularly regarding data privacy, potential for bias, and accountability for errors [52,53].

4.3. Future Directions

Building upon the current systems, several avenues for future work are identified to further enhance their capabilities and clinical applicability.

Future iterations of the simulator will focus on increasing its physiological comprehensiveness and dynamic responsiveness. A multivariate GAN will integrate additional vital signs, such as oxygen saturation (SpO₂), blood pressure, and glucose levels, to provide a more holistic representation of neonatal health status. The use of Recurrent Conditional GANs may better capture dependencies between different vital signs over time [27], while larger multivariate and neonatal-specific training data, as in [54], will lead to more realistic vital sign generators. The lack of patient datasets containing vital signs with concurrent annotations of interventions and diagnoses represents a challenge to developing truly realistic neonatal patient simulators. Intervention modeling will also be refined by incorporating patient-specific contexts like gestational age and prior medical history, allowing for increased realism. The duration of discrete care events can also be modeled with a simple extension to the simulator. The reference materials (from [17]) provided to the NPSS provide basic HR ranges for infants falling within relatively coarse ranges. However, HR is known to vary with gestational age, postnatal age, and sleep/wake/agitation state. This motivates future extension of the simulator to include both post-conceptual and post-natal age, and also to simulate the sleep/wake/agitation state of the infant.

Currently, the simulation of vital signs and discrete clinical interventions is not linked. Future work will evolve the generator into a dynamic, closed-loop system where vital signs respond causally to simulated interventions. This represents a significant architectural shift from the current GAN-based approach and would likely require moving to a framework based on reinforcement learning or recurrent state-space models. Such a system could more accurately model the complex feedback loops of patient deterioration and recovery [55]. Finally, improvements to the user interface, including real-time plotting and live preview capabilities, will be pursued for continuous refinement and improved usability.

Future work on the NPSS will focus on strengthening factual robustness and deployment safety within high-stakes NICU environments. Although automated evaluation demonstrated consistently high relevance (0.95–0.99) and strong groundedness (0.80–0.91 across three judges), the observed variability in groundedness scoring highlights the need for additional system-level safeguards beyond prompt engineering and retrieval refinement.

Several automated mitigation strategies are planned. First, schema validation mechanisms will be incorporated to ensure that all structured outputs (e.g., event counts, intervention timelines, vital sign summaries) strictly conform to expected clinical data formats and simulator-derived ground truth patient data. Second, contradiction detection modules will be integrated to compare generated statements against the underlying structured data and flag discrepancies prior to output presentation. Third, citation-to-data linking will be implemented, requiring generated clinical statements to be explicitly traceable to specific segments of retrieved patient data or reference material, thereby increasing transparency and auditability.

In addition, tighter RAG constraints and retrieval precision tuning will be explored to further improve factual grounding consistency. The existing NICU Patient Simulator and automated multi-judge evaluation pipeline provide a controlled testbed for systematically evaluating such enhancements. This infrastructure can also be used to benchmark future LLM releases within the neonatal clinical summarization domain.

Ultimately, while human oversight remains essential in clinical contexts, future iterations of the NPSS will prioritize layered automated guardrails to reduce reliance on post hoc review and increase reliability for real-world deployment. True clinical deployment of the NPSS will also contend with evolving regulations in this space, similar to those faced by emerging AI Scribe technologies.

This study has used an LLM-as-a-judge approach to evaluate the quality of generated patient summaries, given the input patient data and the retrieved reference materials. LLMs have been shown to be highly effective judges exhibiting strong correlation with human ratings; however, they can suffer from several forms of bias, especially when the same model is used for both generator and judge [56]. The next critical step for the NPSS is to conduct a formal user study, where clinical or parent end-users assess generated text for accuracy, tone, clarity, and completeness. When crafting the system prompt for each use case (parent update, nurse shift summarizer, etc.), we consulted with both clinicians and parents of children in the NICU to ensure that an appropriate tone and level of detail were achieved. However, a formal evaluation by actual end-users is required to confirm the quality of the generated text. In addition to text accuracy and tone, the benefit in terms of workload should also be quantified, as in ref. [31].

In addition to validating the NPSS using simulated patient data, an additional validation step will involve using de-identified data from actual NICU patients, along with clinician-generated text summaries. Such a study will permit direct comparison between LLM-generated and clinician-generated summaries, following best practices for evaluation of LLM-generated text [57].

A significant long-term goal is the integration of these systems, particularly the Auto-Charter module, with existing EHR infrastructures. This will require use of healthcare interoperability standards such as HL7/FHIR, while also navigating the significant practical hurdles of hospital IT governance, data security protocols, and clinical workflow integration [58]. Lastly, the current system relies on OpenAI’s models; transitioning to local, open-source LLMs could address cost and data privacy concerns, though this presents its own challenges regarding model performance and resource requirements [59].

5. Conclusions

This project successfully developed and validated a novel framework for generating descriptive text from neonatal patient vital sign and clinical event data. With further development and validation, this system may address critical needs in NICU documentation, clinical handovers, and parental communication. The first component of this framework, a GAN-driven NICU Patient Simulator, was created to address the challenge of data scarcity: there is a lack of publicly available neonatal patient vital sign data with associated diagnoses and annotated interventions. By integrating statistical methods, the simulator demonstrated considerable fidelity in generating realistic neonatal vital signs and dynamic intervention patterns, providing a robust and safe platform for developing and testing AI-driven healthcare applications. The practical benefit of the neonatal patient simulator is to enable the development of the NPSS and other patient status and care summarization systems. Developing and validating such systems requires large quantities of data for which we know the true answer (patient age, sex, presence of arrhythmia, which interventions took place during the shift, etc.). The simulator provides a mechanism to generate such data.

Source code for the NICU Patient Simulator and the NPSS system prompts for each use case are available at https://github.com/JesseLevine727/NICU_PatientSimulator (accessed on 2 March 2026).

The second component, the NPSS, was designed to ingest these complex vital sign time-series and discrete-event data to generate descriptive text tailored for multiple endpoints. Using a RAG framework to ground its output in the simulated patient data and reliable reference data, the NPSS exhibited strong performance in producing accurate, relevant, and contextually appropriate text for clinicians, parents, and EHRs.

While this integrated approach is promising, challenges related to GAN training stability and the potential for LLM hallucinations were encountered and partially mitigated, highlighting areas for continued research. Crucially, the practical application of such a system requires a human-in-the-loop approach to ensure the veracity and clinical appropriateness of all generated text before it is used for charting or communicated to parents. These safety considerations, alongside the paramount ethical issues surrounding generative AI in sensitive medical settings, must guide future development.

Clinical significance is achieved by the NPSS, which, once fully validated, could alleviate the clinical documentation burden experienced by clinical staff. The ability to digest, summarize, and synthesize several hours of patient status and care events into text for various audiences would permit clinical staff to spend more time on care and less time on documentation. The use of AI Scribes for summarizing spoken exchanges between doctors and patients is growing rapidly because both clinicians and patients benefit. The NPSS is a next step that focuses on data generated by patient monitors and machine learning algorithms (e.g., video-based intervention detection, vital sign estimation, patient segmentation, etc.) rather than spoken exchanges. Continued development and rigorous real-world validation testing will be vital to translating these promising research findings into effective clinical practice.