This is the authors’ copy of the paper to appear in the Proceedings of the 3rd International Workshop on Foundation Models for Cyber-Physical Systems & Internet of Things (FMSys’26).
arXiv:2604.11705v1 [cs.AI] 13 Apr 2026
Agentic Driving Coach: Robustness and Determinism of Agentic AI-Powered Human-in-the-Loop Cyber-Physical Systems Deeksha Prahlad
Daniel Fan
Hokeun Kim
Arizona State University Tempe, AZ, United States [email protected]
Arizona State University Tempe, AZ, United States [email protected]
Arizona State University Tempe, AZ, United States [email protected]
Abstract—Foundation models, including large language models (LLMs), are increasingly used for human-in-the-loop (HITL) cyber-physical systems (CPS) because foundation model-based AI agents can potentially interact with both the physical environments and human users. However, the unpredictable behavior of human users and AI agents, in addition to the dynamically changing physical environments, leads to uncontrollable nondeterminism. To address this urgent challenge of enabling agentic AI-powered HITL CPS, we propose a reactor-model-ofcomputation (MoC)-based approach, realized by the open-source Lingua Franca (LF) framework. We also carry out a concrete case study using the agentic driving coach as an application of HITL CPS. By evaluating the LF-based agentic HITL CPS, we identify practical challenges in reintroducing determinism into such agentic HITL CPS and present pathways to address them. Index Terms—agentic AI, human-in-the-loop, cyber-physical systems, determinism, robustness
I. I NTRODUCTION Foundation models [1], general-purpose large-scale machine learning (ML) models such as large language models (LLMs), have been rapidly adopted by various computing systems. Foundation models are a critical component for agentic AI [2] systems, autonomous systems with goal-directed reasoning. Foundation models and agentic AI have great potential to benefit cyber-physical systems (CPS), such as for complex reasoning [3] or analyzing human activity [4]. This is particularly true for the human-in-the-loop (HITL) CPS [5], as shown in recent use cases of foundation models in HITL CPS for autonomy, personalization, optimization, safety, humanlike interaction, actuation on behalf of humans, etc. [6]–[8] However, using foundation models and LLMs for CPS also raises risks and safety concerns [9]. There have been recent efforts to ensure the robustness and safety of LLM-enabled CPS via formal methods [10] or fine-tuning [11]. Nevertheless, the important problem of ensuring determinism has seldom been explored in the usage of foundation models and agentic AI in CPS, especially in HITL CPS. Determinism, broadly understood as the property of having a single outcome for a given initial state and inputs, plays a key role in enhancing the safety of CPS [12], enabling composability, repeatable testing, predictable behavior, and fault detection. To address this gap, in this paper, we explore pathways toward ensuring determinism in agentic AI-powered HITL CPS leveraging the reactor model of computation (MoC) [13]
via an open-source framework Lingua Franca (LF) [14] for deterministic, concurrent runtime coordination of the reactor MoC. Specifically, we build a model of an example HITL CPS in LF, agentic driving coach, together with the models of a human driver, a car, and a physical environment in LF. Our agentic driving coach demonstrates how we can reconcile the determinism requirement in HITL CPS with the foundation model and human with intrinsic nondeterminism by leveraging reactor MoC and its constructs. II. BACKGROUND AND R ESEARCH C HALLENGES Our proposed HITL CPS model builds on Lingua Franca (LF) [14] as a model-based design framework for the reactor MoC. The reactor MoC, a deterministic variant of the actor MoC [15], is composed of reactors [13] for modeling concurrent components [16]. The reactor MoC achieves determinism via communication through ports, deterministic ordering and scheduling of reactions that implement application-specific logic, and the hierarchical structure allowing a complete topological view of sub-reactors within each composite reactor. The reactor MoC also provides mechanisms (a) to handle deadline violations as exceptions for repeatable and analyzable fault behaviors [17] and (b) to model various latencies in CPS as delayed events with constructs called logical delays for explicit tradeoffs between consistency and availability [18]. A growing body of research focuses on leveraging the capabilities of integrating CPS and advanced machine intelligence [19]–[21]. HITL CPS with agents has been studied for applications across agriculture, robotics, and autonomous systems [22]–[25]. Specifically, LLMs and agentic AI offer strong capabilities for contextual reasoning to generate adaptive behavioral guidance in dynamic CPS environments [26]. However, ensuring determinism in HITL CPS is challenging due to asynchronous events and interaction with the physical world [12], [27]. Srinivasan et al. [28] propose DURA-CPS, which investigates multi-agent evaluation of LLM behavior in simulated CPS. Prior work has demonstrated the use of LF in CPS domains, including automotive systems and AUTOSARbased safety-critical event coordination [29], [30]. But to the best of our knowledge, no prior work has clearly addressed determinism in HITL CPS integrated with agentic AI. Many ML- and AI-based techniques are used to build a driving coach. AutoCoach [31] presents an ML-based driving
r
tio Dr iv
er
Be
In
str
ha v
io
uc
III. P ROPOSED A PPROACH Our proposed approach aims to address the challenge of achieving deterministic modeling of an agentic driving coach as a HITL CPS, given its inherent nondeterminism. Fig. 2 represents our high-level interaction model between the key components of our target system, the agentic driving coach. Agentic coach (Fig. 2a) perceives the human driver (Fig. 2b)’s behavior, as well as the physical world (Fig. 2c), including the environment, and the car. Based on this perception, the coach instructs the driver and sets the actuation command for the car. The driver receives the instruction from the coach while perceiving the environment on their own. Based on the driver’s intent and instruction by the coach, the driver actuates (e.g., accelerates, brakes, steers) the car.
Agentic Coach
s
coach that models driver behavior using supervised learning with support vector machines. Fu et al. [32] utilize LLMs for driving-based scenarios and leverage LLMs’ decisionmaking capabilities. A recent assessment of AI tools for driver monitoring [33] highlights the integration of driverfacing sensors with roadway data to predict SCE. However, these approaches [31], [32] do not consider determinism as a primary challenge in such systems. Fig. 1 demonstrates illustrative challenges introduced by nondeterminism in timing and quality of LLM inferences using an agentic driving coach as an example of agentic HITL CPS. Fig. 1a describes a scenario where a correct (turn-right instruction by the agentic coach), but a delayed response (e.g., 5 seconds after passing the intersection) can lead to a traffic accident. On the contrary, a timely but incorrect instruction (e.g., switch to the left lane instead of the right lane), which can be due to hallucination in LLMs, can also trigger unsafe behavior of the driver, as shown in Fig. 1b. These challenges of response time (Fig. 1a) and accuracy or correctness (Fig. 1b) are intrinsic to LLMs and agentic AI, and their resolution is essential to enable agentic AI-powered HITL CPS. Variable latency in LLM inferences arises from architectural design, model parameters, numerical precision, and quantization. Also, LLM models with larger parameters and higher precision produce quality responses that are critical for HITL CPS. Thus, our primary research goal is to surface this intrinsic nondeterminism in CPS modeling and design, analyze and embrace it, and make the overall system model deterministic despite the inherent nondeterminism in agentic HITL CPS, rather than eliminate it completely.
(a)
ive
(b)
s
(a)
Fig. 1: Challenges faced by an agentic driving coach as an agentic AI-powered HITL CPS. (a) The agent delivers an instruction to the driver too late (at time t + 5). (b) The agent’s instruction is incorrect, although delivered timely at time t.
e rc
Agent (t): Switch to the left lane
te tua Ac
Agent (t): ............... Agent (t+5): Turn right
Pe
n
(b) Human Driver
Actuates Perceives
Physical Plant (Environment and Car)
(c)
Fig. 2: HITL CPS depicting the interaction between the three key components, (a) agentic coach, (b) human driver, and (c) physical plant that includes the environment and car.
A. Problem Formulation Based on the key interactions within the agentic HITL CPS, as shown in Fig. 2, we model the system over n discrete time steps, where time t ∈ {1, . . . , n, . . . }. Let xi denote the initial state of the system. At each time step t, the system receives three inputs: driver behavior ih (t), environmental and car input ic (t), and the agentic coach input ia (t). The resulting system behavior is defined as: y(t) = F (xi , ih (t), ic (t), ia (t))
(1)
where y(t) represents the resulting system behavior at time t and F (·) denotes the system function. Equation (1) states that, for any given initial state and sequential order of driver and coach input, there exists exactly one resulting system behavior. Note that we treat the intrinsic determinism of the HITL CPS as a series of inputs, and model the system such that it behaves deterministically for each set of inputs. B. Reactor model Based on our formalization in Equation (1), we model the agentic HITL CPS shown in Fig. 2, with the reactor MoC using the LF framework to ensure deterministic behavior. Fig. 3 describes our reactor MoC consisting of four reactors, namely Coach (corresponding to the agentic coach in Fig. 2a), Driver (for the human driver in Fig. 2b), as well as Environment and Car (for the physical plant in Fig. 2c). These reactors include reactions (represented by the chevrons in Fig. 3) for implementing the application-specific logic in the target programming language, Python. The Driver reactor models the human driver’s behavior such that upon receiving instructions (via an input port, instr) from the Coach reactor, Driver reacts based on environmental perception and produces control outputs such as accelerator, brake, head position/orientation, and steer actions via output ports. We model continuous human perception using a discrete-event timer (a clock-shaped icon within Driver) that triggers every 100 milliseconds (ms). We also model the time delay between human perception and physical response [34] using logical delays of 500ms (marked red on connections between Driver and Car in Fig. 3). Car receives accelerator, brake, and steering/head positions from Driver, as well as the actuation commands from Coach, via input ports. Then, Car produces the resulting
StopSign 200 ms
(b) Driver accelerator
1 instr
2
brake
head steer
(0 ms, 100 ms)
v
(c) 500 ms
actuate_in
500 ms
brake_in head_pos_in steer_in
Environment
Car
displacement
(a) Coach
s
s
(f)
act
act
Planner planned_instr
instr
v
v
velocity
accel_in
500 ms
(d)
ctrl
steer s
head_pos
LLMInference
instr
(e) control
v
500 ms
250 ms
st
st
h
h
instruction
Fig. 3: Our proposed reactor model implemented using Lingua Franca, targeting the stop sign scenario, consists of four key reactors: (a) Coach, (b) Driver, (c) Car, and (d) Environment. Coach includes two sub-reactors: (e) LLMInference and (f) Planner. TABLE I: Abstracted driver behaviors used in our agentic driving coach model. a represents the acceleration of the car. Driver behavior Accelerator
Brake Head position Steering angle
Behavior Types Coasting Cruise Normal Acceleration Strong Acceleration Gentle braking Emergency braking Left / Right / Center Left / Right / Center
Details a = −0.1 m/s2 a = 0.1 m/s2 a = 2 m/s2 a = 4 m/s2 a = −3.0 m/s2 a = −9.0 m/s2
TABLE II: Notations used in the Equations (2) and (3). Notation vn vn+1 sn sn+1 a ∆t
Description Velocity of the car at time n Velocity of the car at time n + 1 Displacement of the car at time n Displacement of the car at time n + 1 Net acceleration of the car Time interval between two consecutive time steps
car’s physical states over output ports, including velocity, steering, and driver’s head position (e.g., using the car’s interior camera). Our approach adopts a discrete abstraction of driver pedal behavior commonly used in car driving models and control studies [35]. We abstract the car’s states based on the driver’s behaviors (e.g., how much the car accelerates) as shown in the TABLE I. We calculate the car’s velocity for each n discrete time step using the following Equation (2): v(n+1) = v(n) + a × ∆t
(2)
where the notations, vn , vn+1 , a, and ∆t, are defined in TABLE II. The Environment reactor models and outputs the car’s driving environment as displacement (or distance) driven by the car, based on this velocity input, as defined in Equation (3). s(n+1) = s(n) + v(n) × ∆t
(3)
The Coach reactor is a composite reactor that models the agentic driving coach, consisting of two subreactors, LLMInference and Planner. Coach perceives the driver’s behavior as well as the physical world via input ports. Then, Coach internally triggers LLM inference modeled by the LLMInference reactor, which generates a control signal and an instruction, moderated by Planner. LLMInference’s reaction (logic implemented in Python, denoted as a chevron) calls the LLM that is prompted by the structured prompt to be explained later in Section III-C. This reaction uses the deadline-handling mechanism of the reactor MoC and LF to detect excessive and unsafe delays as deadline violations. The language constructs for detecting deadline violation are twofold: • the deadline handler (like an exception handler) definition, denoted by the stopwatch icon and a default deadline value of 250ms (marked red) to be set based on the worst-case inference time measured in Section IV-B, and • the use of LF’s lf_check_deadline() API function [17] to check if the deadline is violated and if violated, call the deadline handler. The deadline handler implements fallback mechanisms to ensure safety (e.g., emergency braking and pulling over), a common approach in autonomous vehicles (e.g., Waymo) [36]. The reaction in LLMInference invokes the text generation of up to 30 tokens with a control signal (control) as described in TABLE III (either NONE, WARNING, or ACTUATE), followed by a sequence of tokens for a driving (instruction), to be fed into Planner. Planner (Fig. 4) implements an LF modal model [37] Planner v
monitoring
where again, the notations are defined in TABLE II.
act ctrl ctrl, instr, s, v
TABLE III: Control signals generated by the LLM for mode transitions in the Planner reactor. Control Signal NONE WARNING ACTUATE
Description No intervention & driver behavior remains within velocity bounds. Driver behavior deviates from velocity bounds. Safety limits are violated & the system triggers actuation.
instr
ctrl, instr, s, v
ctrl, instr, s, v
warning Instr
s
ctrl, instr, s, v
ctrl, s, v
actuate
Fig. 4: The Planner reactor as a modal model where transitions are triggered by control signals defined in TABLE III.
with three modes, monitoring, warning, and actuation. Planner takes displacement and velocity from the physical world as inputs, as well as the control and the instruction from LLMInference, then produces a processed instruction for the driver, planned_instr as an output. The monitoring mode, a default mode that can be entered by the NONE signal, is active when the driver behavior remains within predefined safety bounds (e.g., within the safe velocity). If the driver behavior deviates from the safety bounds but remains within a recoverable margin, the LLM produces WARNING as a ctrl signal to cause Planner to enter the warning mode and issue a corrective instruction. We throttle the rate of corrective instructions to at most 1 instruction per second to prevent the driver from being overwhelmed by too frequent instructions [38]. When the driver’s behavior exceeds the recoverable margins, Planner enters the actuation mode triggered by the ctrl signal ACTUATE, and sends the actuation command via an output port, act, which is connected to the Car reactor. This is similar to a human driving coach applying an emergency brake in the passenger seat. We model the coach-to-actuation delay as a logical delay of 200ms. C. Structured Agentic Coach Prompt In addition to our reactor model, we design a structured LLM prompt for the agentic coach to generate the control signals and driving instructions. We design the prompt such that it reduces verbosity, ambiguity, and the risk of unsafe instructions by embedding tailored rules constraining responses from the agentic coach. Fig. 5 illustrates an example of our structured prompts for the stop sign scenario (one of our evaluation scenarios explained in Section IV-A). Our prompts follow a template provided by Ollama [39]. Our prompts consist of two components: a system message (Lines 3–14 in Fig. 5) that defines the behavioral rules for the agentic driving coach, and a user message (Line 16 in Fig. 5). The system message specifies the required output format and safety rules. We instruct the LLMs to produce exactly one line in the format Signal|Message (Line 4 in Fig. 5). The accompanying message must be a single sentence describing the appropriate driving instruction (Line 6 in Fig. 5). The user message (Line 16 in Fig. 5) provides the current driving
Lane Change Initiated Current Speed 40 km/h
r
Fig. 5: An example structured prompt provided for LLMInference to generate a control signal (denoted as TOKEN) and a driving instruction for the stop sign scenario.
Speed Limit Change Ahead! Velocity Too High!
Stop Sign Ahead! Emergency Braking Applied r
1. result = ollama.chat(model="llama3:8b", messages=[ 2. {"role": "system","content": ( 3. "You are an agentic driving coach." 4. "Output exactly ONE line: TOKEN|Message" 5. "TOKEN must be one of: NONE, WARNING, ACTUATE" 6. "Message must be one sentence, about stop sign approaching only." 7. "Use displacement is s and measured in meters" 8. "velocity is v measured using m/s only." 9. "Rules for TOKEN:" 10. "if s is less than or equal to 25 and v is greater than 2.5 then TOKEN=ACTUATE" 11. "else if s lies between 50 and 60 and v is not between 8 and 10 then TOKEN=WARNING" 12. "else if s is greater than 99 and v is not between 8 and 12 then TOKEN=WARNING" 13. "else TOKEN=NONE" 14. "Do not output anything else."), }, 15. {"role": "user", "content": 16. f"s={s:.2f}m v={v:.2f}m/s st={st} h={h}", }, ], 17. options={"temperature": 0.0, "num_predict": 30}, )
(a)
(b)
(c)
Fig. 6: Three scenarios to evaluate the implementation of the proposed approach. (a) Stop sign, (b) Speed changing, and (c) Lane changing.
context with the numerical and enumeration (Python enum) values of velocity, displacement, steer position, and head position, which are obtained from the environment reactor and the car reactor. We enable context-aware reasoning of the LLMs by inserting runtime values generated by the Driver and Environment reactors during the execution of our reactor model program written in LF. Also, we configure the LLMs to generate a maximum of 30 tokens ("num_predict": 30 at Line 17 of Fig. 5), while controlling randomness ("temperature": 0). IV. E VALUATION We evaluate our agentic driving coach across a range of scenarios and LLMs, demonstrating deterministic, repeatable behavior. Our implementation and results are available in our GitHub repository.1 A. Evaluation Scenarios We use three driving scenarios shown in Fig. 6; (a) stop sign, (b) speed change, and (c) lane change, along with a fixed, manually specified driver’s behavior for each scenario. • Stop sign: A stop sign is located 100m ahead of the car’s initial position. The car starts with an initial velocity of 10m/s and must reach 0m/s at the stop sign. We first define the desirable velocity such that it follows a halfparabolic trajectory to reach 0m/s at the stop sign, and define the safe velocity bounds (upper and lower bounds) as ±2m/s of the desirable velocity. • Speed change: Approaching a speed limit sign at 100m distance, the car needs to decelerate from 18m/s to 11m/s. • Lane change: The car needs to change lanes to the right within 100m while maintaining a velocity of 18m/s to prepare for the right turn. The driver must check right, maintain speed, and steer into the right lane. B. Experimental Setup and Choice of Deadlines This section describes the experimental setup of our evaluation and how we measure the LLM inference latency and configure deadlines of the deadline handler of the LLMInference reactor in Fig. 3. We use locally deployed 4-bit quantized Llama 3 models [40] with different numbers of parameters (1B, 8B, and 70B) using the Ollama runtime [39] running on a workstation with Intel Xeon w9-3475X (36 cores, 2.2 GHz to 4.8 GHz), 1 https://github.com/asu-kim/agentic-driving-coach.git, which includes LF scenarios: StopSign.lf, SpeedChange.lf, and LaneChange.lf.
(a) Stop sign, Llama 3 1B
(b) Stop sign, Llama 3 8B
(c) Stop sign, Llama 3 70B
Fig. 7: Evaluation results illustrating velocity vs. displacement and time for three Llama 3 models (1B, 8B, 70B) in a stop sign scenario. Blue lines show car velocity; solid/dashed red lines show safety bounds of car velocity. Red X marks deadline violations in LLMInference. Green and orange triangles indicate coach instructions and actuation commands, respectively.
(a) Speed change, Llama 3 8B
(b) Speed change, Llama 3 70B
(c) Lane change, Llama 3 8B
(d) Lane change, Llama 3 70B
Fig. 8: Evaluation results with Llama 3 (8B vs. 70B) in speed and lane change scenarios, illustrated by velocity vs. displacement and time.
256 GB DDR5 main memory, and NVIDIA RTX 6000 Blackwell Pro GPU with a preloaded LLM. We run the LLM inference of each model using our structured prompt tailored for each scenario 300 times, and choose the worst-case measured latency as the deadline of LLMInference’s deadline handler for the LF programs using the corresponding Llama model. The measured worst-case latencies for the Llama 3 models with different numbers of parameters are: (a) 1B parameters: 186ms, (b) 8B parameters: 250ms, and (c) 70B parameters: 613ms. C. Experimental Results and Discussion In this section, we discuss the evaluation results and their deterministic behaviors with the three Llama 3 models with 1B, 8B, and 70B parameters. Overall, we confirm that for the same timing of inference and for the same control signals and driving instructions from the driving coach, as well as the same human driver’s behavior, our reactor model always produces the same output behavior, including the deadline misses and handling, as well as the car’s driving behavior in terms of the velocity and the displacement. Thus, we empirically validate that our reactor model demonstrates the deterministic behavior for the same initial states (initial displacement and initial velocity) and the same series of inputs (timing and accuracy of the LLM inferences and human driver behavior). While the overall car’s driving behavior and the deadline misses in our reactor model vary with different inputs, we present representative experimental results in Figs. 7 and 8. Although we use the worst-case measured latency as deadlines, the results show some deadline misses, mainly because (a) the overhead and interference from LF program execution, (b) the LLM inference is frequently triggered every 100ms, and (c) the prolonged inference time when the driver’s behavior and the car’s velocity and acceleration change dynamically. However, considering that the LLM inference is triggered every 100ms, the deadline misses are relatively rare. Fig. 7 illustrates evaluation results for the stop sign scenario with three different-sized LLM models. Fig. 7a shows that the car fails to slow down and stop at the stop sign (at 100 m), because the Llama 3 1B fails to produce correct driving
instructions or actuation commands. We conclude that the inference accuracy of Llama 3 1B is dangerously low and unsuitable as the foundation model for an agentic driving coach, even though its inference latency is lower than that of larger Llama models. Fig. 7b and Fig. 7c show the results using the Llama 3 8B and 70B models, respectively. We find that the larger model (70B) produces fewer driving instructions and actuation commands, while letting the driver stop the car nearer to the stop sign compared to the smaller model (8B), indicating that the larger, more accurate foundation model leads to safer behavior in agentic HITL CPS. Fig. 8 shows the evaluation results for the speed change and lane change scenarios, using Llama 3 8B and 70B models. We exclude the 1B model results from the figure, as it also leads to unsafe driving behavior in these two scenarios. As shown in the results from the speed change scenario in Fig. 8a and Fig. 8b, again the larger model (70B) successfully guides the student driver to reduce the speed to the new speed limit with fewer instructions and actuation commands, although both models encounter deadline misses, which trigger fallback mechanisms in the deadline handler to be engaged. Fig. 8c and Fig. 8d illustrate the experimental results for the lane change scenario, we find that there are more deadline misses compared to the other two scenarios, partially due to the increased overhead of the coach to monitor the head position/orientation of the driver (to check if the driver checks the right lane before steering) as well as the car’s velocity and acceleration. Similar to the other two scenarios, the larger model (70B) leads the human driver into the right lane with fewer instructions and actuation commands than the smaller model (8B). V. C ONCLUSION In this paper, we explore a methodology to ensure the robustness and determinism of agentic AI-powered HITL CPS, using a concrete use case: an agentic driving coach modeled with the reactor MoC and the Lingua Franca (LF) framework. Our reactor MoC-based agentic driving coach model achieves deterministic behavior in response to the same inputs of the driver’s behavior and the coach’s control signals and driving instructions, in terms of timing and accuracy. Our reactor
model provides a timely and safe fallback mechanism in case the LLM inference is delivered late, with hard-coded rules. As future work, we will build an integrated, single LF program for an agentic driving coach that supports multiple scenarios. Furthermore, we will incorporate advanced LLM fine-tuning techniques such as retrieval-augmented generation (RAG) [41] or low-rank adaptation (LoRA) [42] to reduce inference latency while providing LLM agents with contextenriched prompts. We will also integrate our hardware setup and evaluate our agentic driving coach with real-time sensor inputs from human drivers to further study common human behaviors across a wider range of scenarios. ACKNOWLEDGMENT This work was supported in part by NSF under Award No. POSE-2449200 (An Open-Source Ecosystem to Coordinate Integration of Cyber-Physical Systems). R EFERENCES [1] R. Bommasani et al., “On the opportunities and risks of foundation models,” arXiv preprint arXiv:2108.07258, 2021. [2] J. Fang et al., “A comprehensive survey of self-evolving AI agents: A new paradigm bridging foundation models and lifelong agentic systems,” arXiv preprint arXiv:2508.07407, 2025. [3] L. Han et al., “Toward foundation models for online complex event detection in CPS-IoT: A case study,” in Proc. of the 2nd Int’l Workshop on Foundation Models for Cyber-Physical Systems & Internet of Things (FMSys), 2025, pp. 1–6. [4] L. Xu, K. Hou, and X. Jiang, “Exploring the capabilities of llms for IMU-based fine-grained human activity understanding,” in Proceedings of the 2nd International Workshop on Foundation Models for CyberPhysical Systems & Internet of Things, 2025, pp. 13–18. [5] G. Schirner et al., “The future of human-in-the-loop cyber-physical systems,” Computer, vol. 46, no. 1, pp. 36–45, 2013. [6] J. M. Fernandes et al., “People 4.0—a model for human-in-the-loop CPS-based systems,” Computer Standards & Interfaces, vol. 91, p. 103895, 2025. [7] A. Banerjee et al., “CPS-LLM: large language model based safe usage plan generator for human-in-the-loop human-in-the-plant cyber-physical system,” arXiv preprint arXiv:2405.11458, 2024. [8] H. Yang, M. Siew, and C. Joe-Wong, “An LLM-based digital twin for optimizing human-in-the loop systems,” in IEEE Int’l Workshop on Foundation Models for Cyber-Physical Systems & IoT (FMSys). IEEE, 2024, pp. 26–31. [9] W. Xu et al., “LLM-enabled cyber-physical systems: Survey, research opportunities, and challenges,” in 2024 IEEE International Workshop on Foundation Models for Cyber-Physical Systems & Internet of Things (FMSys). IEEE, 2024, pp. 50–55. [10] A. Hafez et al., “Safe LLM-controlled robots with formal guarantees via reachability analysis,” arXiv preprint arXiv:2503.03911, 2025. [11] T. Kimura et al., “On the efficiency and robustness of vibrationbased foundation models for IoT sensing: A case study,” in IEEE Int’l Workshop on Foundation Models for Cyber-Physical Systems & IoT (FMSys). IEEE, 2024, pp. 7–12. [12] E. A. Lee, “Determinism,” ACM Transactions on Embedded Computing Systems (TECS), vol. 20, no. 5, pp. 1–34, 2021. [13] M. Lohstroh et al., “Reactors: A deterministic model for composable reactive systems,” in International Workshop on Design, Modeling, and Evaluation of Cyber Physical Systems. Springer, 2019, pp. 59–85. [14] ——, “Toward a Lingua Franca for deterministic concurrent systems,” ACM Trans. on Embedded Computing Syst. (TECS), vol. 20, no. 4, 2021. [15] C. Hewitt, P. Bishop, and R. Steiger, “A universal modular actor formalism for artificial intelligence,” in Proc. of the 3rd Int’l Joint Conf. on Artificial Intelligence, San Francisco, CA, USA, 1973, p. 235–245. [16] M. Lohstroh et al., “Actors revisited for time-critical systems,” in Proc. of the 56th Annual Design Automation Conference, 2019, pp. 1–4. [17] E. A. Lee et al. (2025, Aug.) Working with deadlines. Lingua Franca Project. [Online]. Available: https://www.lf-lang.org/blog/deadlines/ #reactions-that-monitor-their-execution-time
[18] ——, “Consistency vs. availability in distributed cyber-physical systems,” ACM Trans. on Embedded Computing Syst., vol. 22, no. 5s, pp. 1–24, 2023. [19] S. Lee et al., “Cyber-physical AI: Systematic research domain for integrating ai and cyber-physical systems,” ACM Trans. Cyber-Phys. Syst., vol. 9, no. 2, 2025. [20] W. Sritriratanarak and P. Garcia, “Cyber physical games: Rational multiagent decision-making in temporally non-deterministic environments,” ACM Trans. Cyber-Phys. Syst., vol. 9, no. 2, Apr. 2025. [21] L. Niu et al., “Who is responsible? explaining safety violations in multiagent cyber-physical systems,” in 2024 International Conference on Assured Autonomy (ICAA), 2024, pp. 11–20. [22] G. Wang et al., “Voyager: An open-ended embodied agent with large language models,” arXiv preprint arXiv:2305.16291, 2023. [23] J. E. Rivadeneira et al., “A unified privacy preserving model with ai at the edge for human-in-the-loop cyber-physical systems,” Internet of Things, vol. 25, p. 101034, 2024. [24] M. Sreeram and S. Y. Nof, “Human-in-the-loop: role in cyber physical agricultural systems,” International Journal of Computers Communications & Control, vol. 16, no. 2, 2021. [25] M. Gil et al., “Designing human-in-the-loop autonomous cyber-physical systems,” International journal of human-computer studies, vol. 130, pp. 21–39, 2019. [26] L. Burgueño et al., “A human behavior exploration approach using LLMs for cyber-physical systems,” in Proc. of the ACM/IEEE 27th Int’l Conf. on Model Driven Eng. Languages and Syst., 2024, pp. 578–586. [27] M. Lohstroh et al., “Deterministic coordination across multiple timelines,” ACM Transactions on Embedded Computing Systems, vol. 23, no. 5, pp. 1–29, 2024. [28] T. Srinivasan et al., “Dura-cps: A multi-role orchestrator for dependability assurance in llm-enabled cyber-physical systems,” in 2025 55th Annual IEEE/IFIP International Conference on Dependable Systems and Networks Workshops (DSN-W). IEEE, 2025, pp. 63–70. [29] S. Bateni et al., “Risk and mitigation of nondeterminism in distributed cyber-physical systems,” in Proceedings of the 21st ACM-IEEE International Conference on Formal Methods and Models for System Design, ser. MEMOCODE ’23. ACM, 2023, p. 1–11. [30] C. Menard et al., “Achieving determinism in adaptive autosar,” in 2020 Design, Automation & Test in Europe Conference & Exhibition (DATE), 2020, pp. 822–827. [31] Z. Marafie et al., “Autocoach: Driving behavior management using intelligent iot services,” in 2019 IEEE 12th Conference on ServiceOriented Computing and Applications (SOCA), 2019, pp. 103–110. [32] D. Fu et al., “Drive like a human: Rethinking autonomous driving with large language models,” in 2024 IEEE/CVF Winter Conf. on App. of Computer Vision Workshops (WACVW). IEEE, 2024, pp. 910–919. [33] G. Yang et al., “Comprehensive assessment of artificial intelligence tools for driver monitoring and analyzing safety critical events in vehicles,” Sensors, vol. 24, no. 8, 2024. [34] H. Han et al., “Driver’s avoidance characteristics to hazardous situations: A driving simulator study,” Transportation research part F: traffic psychology and behaviour, vol. 81, pp. 522–539, 2021. [35] T. Gillespie, Fundamentals of vehicle dynamics. SAE international, 2021. [36] M. Schwall et al., “Waymo public road safety performance data,” arXiv preprint arXiv:2011.00038, 2020. [37] A. Schulz-Rosengarten et al., “Polyglot modal models through Lingua Franca,” in Proceedings of Cyber-Physical Systems and IoT Week 2023, 2023, pp. 337–342. [38] S. Huang et al., “Chatbot and fatigued driver: Exploring the use of llmbased voice assistants for driving fatigue,” in Extended Abstracts of the CHI Conference, 2024, pp. 1–8. [39] F. S. Marcondes et al., “Using Ollama,” in Natural Language Analytics with Generative Large-Language Models: A Practical Approach with Ollama and Open-Source LLMs. Springer, 2025, pp. 23–35. [40] A. Grattafiori et al., “The Llama 3 herd of models,” arXiv preprint arXiv:2407.21783, 2024. [41] D. Prahlad, C. Lee, D. Kim, and H. Kim, “Personalizing large language models using retrieval augmented generation and knowledge graph,” in Companion Proceedings of the ACM on Web Conference (WWW) 2025, 2025, pp. 1259–1263. [42] J. Zhao et al., “Galore: Memory-efficient llm training by gradient lowrank projection,” arXiv preprint arXiv:2403.03507, 2024.