Agentic AI for Real-Time Adaptive PID Control of a Servo Motor

Abstract

This study explores a novel approach of using large language models (LLMs) in the real-time Proportional–Integral–Derivative (PID) control of a physical system, the Quanser QUBE-Servo 2. We investigated whether LLMs, used with an Artificial Intelligence (AI) agent workflow platform, can participate in the live tuning of PID parameters through natural language instructions. Two AI agents were developed: a control agent that monitors the system performance and decides if tuning is necessary, and an Optimizer Agent that updates PID gains using either a guided system prompt or a self-directed free approach within a safe parameter range. The LLM integration was implemented through Python programming and Flask-based communication between the AI agents and the hardware system. Experimental results show that LLM-based tuning approaches can effectively reduce standard error metrics, such as IAE, ISE, MSE, and RMSE. This study presents one of the first implementations of real-time PID tuning powered by LLMs, and it has the potential to become a novel alternative to classical control, as well as machine learning or reinforcement learning-based approaches. The results are promising for using agentic AI in heuristic-based tuning and the control of complex physical systems, marking the shift toward more human-centered, explainable, and adaptive control engineering.

1. Introduction

The integration of Artificial Intelligence (AI) into control systems has shown significant potential in recent years [1]. Many researchers and industry leaders are currently implementing AI into control systems to enhance performance, simplify control processes, and enable human–machine interactions (HMIs) [2,3,4]. This trend is driven by advancements in computer vision, deep learning, and reinforcement learning, as well as the rise of large language models (LLMs), and has opened up new opportunities for innovative applications across various engineering fields [5,6]. For example, modern robotic and control systems have evolved from completing set tasks in controlled environments to displaying intelligent behaviors by performing master–slave operations, learning from stored datasets, and adapting through real-time human–robot and human–machine interactions [7,8,9]. Other AI-based control systems incorporate multiphase reinforcement learning frameworks for PID tuning, demonstrating how deterministic policy gradients and neural networks can enable dynamic self-tuning [10,11,12]. Evolutionary, neural network, computer vision-based feedback, and heuristic approaches were also used to enhance tuning by incorporating Artificial Intelligence [13,14,15]. In a recent work, researchers utilized LLM agents/controllers to guide the adaptive compensator and dynamically adjust robot control policies as needed with minimal manual intervention [16,17].

Although numerous types of controllers exist, PID controllers have been among the most widely used controllers in industrial automation for decades, as they are simple and easy to implement. Over the years, many PID tuning strategies have been developed, including the heuristic rules of Ziegler–Nichols [18], Cohen–Coon [19,20], and Chien–Hrones–Reswick [21,22], as well as relay auto-tuning [23,24,25] and Internal Model Control (IMC)-based designs [26]. These strategies remain valuable in modern practice, but they share common limitations. Once tuned, the controllers typically remain static and require manual adjustments to handle disturbances, model drift, or nonlinearities. In addition, they offer little interpretability for human operators beyond numerical gain values. While modern control methods such as LQR [27,28,29,30], Model Predictive Control (MPC) [31], and ${\mathcal{H}}_{\infty }$ control [32,33,34] address many of the limitations of classical tuning approaches by offering systematic optimization and robustness guarantees, they remain mathematically intensive and often inaccessible to practitioners without specialized training. Moreover, these approaches still lack the ability to interact intuitively with human operators. In this context, recent advances in large language models (LLMs) and agentic AI integrations create new possibilities: controllers that not only tune parameters adaptively but also engage in natural human–machine dialogue, explaining decisions, and responding to user input during operation. Beyond dialogue, such AI agents can act with more independence by deciding when to run or stop machines based on various streams of feedback. This moves the system beyond rigid, pre-programmed control logic to a more intelligent and context-aware decision-making tool.

Recent studies show that, when LLMs are embedded in feedback-driven control systems, they can provide explainability and adaptability beyond what classical optimization achieves. For example, systems such as InCoRo combine an LLM controller with scene understanding to adjust actions in dynamic environments [35]. Other frameworks, such as BTLA, utilize LLMs to interpret system states and support operators in real-time [36]. More recently, methods such as Think, Act, Learn, and interpretable behavior-tree control show that LLMs can reflect on execution feedback, change parameters, and offer semantic reasoning [37]. In these contexts, the LLM acts less as a “solution generator” and more as an adaptive collaborator that improves established strategies with real-time understanding and flexibility.

In this study, we used an LLM-based AI agent to control a servo motor via adaptive PID tuning. While most work in this field is carried out on simulated robotic environments or abstracted dynamics, in this research, we deployed an LLM-based PID tuning agent in a real-time hardware setup. This hands-on approach addresses practical challenges such as real-time constraints, sensor noise, actuator delays, and safety limits.

To fine-tune the PID parameters of the system, we embedded LLM agents within an automated workflow by n8n [38]. This method shows real-time decision-making and closed-loop adjustments of LLM, connecting high-level AI reasoning and low-level motor control. Compared to the best of the current literature, this marks one of the first known instances of using LLMs to autonomously tune PID parameters for a physical system during real-time operation, not just generating control policies offline or in simulations. This research also validates LLM-based control and demonstrates its practical viability, extending beyond offline control, theoretical models, and digital twins.

2. Materials and Methods

2.1. Hardware

To implement a real-time Proportional–Integral–Derivative (PID) tuning using AI agents, a direct-drive DC motor with an integrated optical encoder is used. The hardware needs to provide accurate measurements and rapid actuation to maintain stable and responsive real-time control. For this purpose, we have used the Quanser QUBE-Servo 2 system, which integrates a DC motor mechanism with position feedback through an encoder [39]. This device can be operated with either a load disk or a pendulum attachment. In this study, we utilized the load disk with the rotary servo platform. Figure 1 shows a schematic diagram of the QUBE-Servo 2 setup with the inertia disk. Here, the DC motor shaft is connected to a load hub and disk, which together define the rotational inertia of the system (Figure 1).

2.1.1. Electromechanical Parameters

In the Quanser QUBE-Servo 2 system, the parameters $R_m$, $k_t$, $k_m$, $J_m$, $L_m$, $m_h$, $r_h$, $J_h$, $m_d$, and $r_d$ represent the terminal resistance ($8.4\Omega$), torque constant ($0.042\mathrm{Nm}/\mathrm{A}$), motor back electromotive force (emf) constant ($0.04\mathrm{V}/(\mathrm{rad}/\mathrm{s})$), rotor inertia ($4.0\times {10}^{-6}\mathrm{kg}·{\mathrm{m}}^2$), rotor inductance ($1.16\mathrm{mH}$), load hub mass ($0.0106\mathrm{kg}$), load hub radius ($0.0111\mathrm{m}$), load hub inertia ($0.6\times {10}^{-6}\mathrm{kg}·{\mathrm{m}}^2$), mass of the disk load ($0.053\mathrm{kg}$), and radius of the disk load ($0.0248\mathrm{m}$), respectively.

2.1.2. Servo Motor and Model

The Quanser QUBE-Servo 2 system uses a high-performance coreless DC motor and an optical incremental encoder to make the platform responsive for real-time controls. The motor has a smooth and rapid torque response, and the optical encoder can record up to 2048 quadrature states per revolution, providing very accurate velocity and position feedback during control operation.

The dynamic behavior of the QUBE-Servo 2 system can be described using a first-order linear differential equation derived through first-principles modeling. From that dynamic behavior, we can find a voltage-to-speed transfer function: ${\displaystyle \frac{{\mathrm{\Omega }}_m\left(s\right)}{V_m\left(s\right)}}$. For the position control, this voltage-to-speed transfer function can be further simplified to obtain a voltage-to-position transfer function as ${\displaystyle \frac{{\mathrm{\Theta }}_m\left(s\right)}{V_m\left(s\right)}}$. However, in this study, we have used a heuristic tuning approach, where an AI agent iteratively adjusts the PID gains ($K_p$, $K_i$, and $K_d$) based on observed performance metrics (rise time, overshoot, steady-state error, etc.). This approach does not require an explicit mathematical model and, therefore, the dynamic modeling of the servo is not presented here.

2.2. PID Control

To fine-tune the servo system’s performance, we utilized the classical PID controller that regulates the motor voltage based on the tracking or position error. The system was evaluated using a square wave input with an amplitude of $\pm {\displaystyle \frac{\pi }{3}}$ and a period of 12 s. The position error was determined by calculating the difference between the desired signal and the actual response. It then uses PID gains to generate input, $u\left(t\right)$, to the system plant. In the time domain, the input is generated based on the error, as shown in Equation (1).

$$u\left(t\right)=K_P.e\left(t\right)+K_I\int e\left(t\right)dt+K_D{\displaystyle \frac{de\left(t\right)}{dt}}$$

(1)

Here, $e\left(t\right)$ is the error function, $u\left(t\right)$ is the input to the system plant after PID operation, and $K_P$, $K_I$, and $K_D$ are proportional, integral, and derivative gains, respectively. A simplified block diagram of this control is presented in Figure 2.

2.3. Derivative Filter and Frequency Control

In the real-time PID control of electromechanical systems, the derivative term is highly susceptible to noise due to the amplification of high-frequency components. To damp this noise, we have applied a discrete-time adaptive low-pass filter after the derivative calculation. This filter employs a first-order exponential smoothing method that balances noise suppression and responsiveness. The derivative filter first computes the raw derivative as the difference between the current and previous error values divided by the elapsed time, $\Delta t$ (Equation (2)):

$$d_{\mathrm{raw}}\left[n\right]={\displaystyle \frac{de\left(t\right)}{dt}}={\displaystyle \frac{e\left(t\right)-e(t-\Delta t)}{\Delta t}}$$

(2)

Here, $d_{\mathrm{raw}}\left[n\right]$ is the current raw derivative. After this step, the current filtered derivative, $d_{\mathrm{filtered}}\left[n\right]$, is calculated using Equation (3).

$$d_{\mathrm{filtered}}\left[n\right]=\alpha \times d_{\mathrm{filtered}}[n-1]+(1-\alpha )\times d_{\mathrm{raw}}\left[n\right]$$

(3)

Here, $\alpha$ is a smoothing factor determined dynamically at each time step using Equation (4).

$$\alpha ={\displaystyle \frac{T_d}{T_d+\Delta t}}$$

(4)

In Equation (4), $T_d$ = time constant parameter (set to 0.005 s).

This adaptive filtering approach accounts for variations in the control loop’s timing and provides more stable derivative feedback in real-time environments.

A frequency control mechanism is also integrated into the algorithm to regulate how often data logging and plotting are performed. Since the PID control loop of QUBE-Servo 2 is set to operate at a high frequency (500 Hz), by default, it is capable of doing precise actuations and fast updates. However, data logging in dynamic plots and exporting performance metrics are set to 50 Hz to maintain smooth operations and plotting. We have used a counter to track the number of control loop iterations, and only every 10th iteration triggers a data-capturing operation. Based on our experiment, this rate mitigates heavy input–output operations of the high-frequency servo control system and supports efficient optimization by the agentic framework. The combination of adaptive derivative filtering and a frequency control mechanism can perform effective real-time PID fine-tuning. For a sensitive and fast electromechanical system like QUBE-Servo 2, these steps are crucial for reliable and stable operations.

2.4. Calculation of Error Metrics

To evaluate the effectiveness of the real-time PID control algorithm with the QUBE-Servo 2 system, we used a set of error metrics based on the system’s response to square wave inputs. These metrics provide insight into the system’s behavior during both the transient phase and steady state. They are critical for real-time PID tuning through the AI agent and for automatically evaluating control performance. In our study, the program records the time, the reference position (desired), and the actual position at each control step. Once the system stabilizes after each positive step change, it calculates the other key performance metrics, as shown in Section 2.4.1, Section 2.4.2, Section 2.4.3, Section 2.4.4 and Section 2.4.5.

2.4.1. Overshoot and Steady-State Error

Peak overshoot is measured by calculating the amount by which the system output exceeds the desired setpoint during the transient phase. Using the maximum measured position, $y_p\left(t\right)$, and input, $r\left(t\right)$, for a square wave, the percentage of overshoot is determined by Equation (5).

$$\mathrm{Overshoot}\mathrm{\%}=\left({\displaystyle \frac{y_{\mathrm{p}}\left(t\right)-r\left(t\right)}{r\left(t\right)}}\right)\times 100$$

(5)

The steady-state error (SSE) is measured by calculating the difference between the measured output ($y\left(t\right)$) and the input signal after the system has settled (Equation (6)).

$$\mathrm{SSE}=\left|r\left(t\right)-y\left(t\right)\right|$$

(6)

2.4.2. Rise Time and Settling Time

Rise time presents how fast the system responds, and it is measured by calculating the time for the response to increase from $10\%$ to $90\%$ of the input signal (Equation (7)).

$$\mathrm{Rise}\mathrm{Time}=t_{90\%}-t_{10\%}$$

(7)

The settling time was determined by calculating the duration after which the system response remained within $5\%$ of the input signal for at least $0.5$ s. In some cases, especially when the SSE was large, the system did not reach a settling point.

2.4.3. Integral Absolute Error (IAE)

The Integral Absolute Error (IAE) is determined by integrating the absolute value of the instantaneous error over time. It measures the total size of the error, regardless of its direction (Equation (8)).

$$\mathrm{IAE}={\int }_0^T\left|e\left(t\right)\right|dt\approx \sum _{i=1}^n\left|e_i\right|·\Delta t$$

(8)

Here, $e\left(t\right)=r\left(t\right)-y\left(t\right)$ is the control error, $r\left(t\right)$ is the reference position, and $y\left(t\right)$ is the measured position. This metric is very sensitive to prolonged errors [40,41].

2.4.4. Integral Squared Error (ISE)

The Integral Squared Error (ISE) gives more weight to large errors by squaring the instantaneous error before integrating. This measure is more responsive to peaks in the response and punishes high overshoots or oscillations (Equation (9)).

$$\mathrm{ISE}={\int }_0^{T}e{\left(t\right)}^{2}dt\approx \sum _{i=1}^n{e}_i^2·\Delta t$$

(9)

ISE emphasizes larger errors by giving them greater weight. This makes it useful for PID tuning in situations where high precision is required. However, it does not consider the timing of errors and is less effective in oscillating systems where squared errors can cancel each other out [40,41].

2.4.5. Mean Absolute Error (MAE)

The Mean Absolute Error gives the average of all absolute errors during the evaluation period (Equation (10)).

$$\mathrm{MAE}={\displaystyle \frac{1}{n}}\sum _{i=1}^n\left|e_i\right|$$

(10)

Here, n is the total number of error samples or data points. This metric directly measures the extent to which the system deviates from its intended path.

2.4.6. Root Mean Squared Error (RMSE)

The Root Mean Squared Error is a widely used metric that aggregates the square of the errors and takes the square root of their mean (Equation (11)).

$$\mathrm{RMSE}=\sqrt{{\displaystyle \frac{1}{n}}\sum _{i=1}^n{e}_i^2}$$

(11)

Here, n is the total number of error samples or data points. Unlike MAE, RMSE penalizes larger errors more and is usually more sensitive to outliers. It provides a reliable measure of control precision when occasional deviations need to be recorded.

2.4.7. Integral Time-Weighted Absolute Error (ITAE)

The Integral Time-Weighted Absolute Error (ITAE) is a refined metric. It multiplies the absolute error by the time (t) before integration. This means that errors that persist longer in the control window are penalized more severely (Equation (12)).

$$\mathrm{ITAE}={\int }_0^{T}t·\left|e\left(t\right)\right|dt\approx \sum _{i=1}^n{t}_i·\left|e_i\right|·\Delta t$$

(12)

Here, n is the total number of error samples or data points. This metric promotes the quick removal of errors and a smooth settling process. It is commonly used in controller design for systems where late-stage errors cause more disruption than early errors [41].

2.4.8. Integral Time-Weighted Squared Error (ITSE)

The Integral Time-Weighted Squared Error (ITSE) applies a time-weighted penalty, but using squared error terms (Equation (13)).

$$\mathrm{ITSE}={\int }_0^{T}t·e{\left(t\right)}^{2}dt\approx \sum _{i=1}^n{t}_i·e_i^2·\Delta t$$

(13)

Here, n is the total number of error samples or data points. ITSE is more sensitive to long-lasting, high-magnitude errors [41].

2.5. Agentic AI Framework

We have implemented a hierarchical, agentic AI framework for the PID tuning of the Quanser QUBE-Servo 2 platform. The servo system is controlled in real time using a Python program, and a Flask server (Web Server Gateway) is used to interface with AI agents. The Flask server can handle incoming HTTP requests and execute corresponding Python functions to serve web pages or APIs for data communication [42,43]. The goal of the agent is to fine-tune the proportional ($Kp$), integral ($Ki$), and derivative ($Kd$) gains to minimize overshoot, rise time, and steady-state error (SSE). The program starts with arbitrary PID values ($Kp=0.1,Ki=0.0,Kd=0.0$) that require further tuning. The control loop of the program runs at 500 Hz, and it can update $Kp$, $Ki$, and $Kd$ values while the system is running if directed by AI agents through the Flask server.

As a reference input, the program generates a square wave signal with an amplitude of $\pm {\displaystyle \frac{\pi }{3}}$ radians and a period of 12 seconds. To follow the signal, the QUBE-Servo 2 system measures motor position, applies exponential smoothing to reduce noise, and calculates the control voltage based on the PID formula and a filtered derivative term. The filtered derivative is implemented using the function ${\displaystyle \frac{T_d}{T_d+\Delta t}}$, and it helps to prevent high-frequency amplification that often occurs in noisy settings. For safe operation, the voltage commands are clipped to the safe operating range of $\pm 8$ V before they are sent to the servo motor.

2.6. Real-Time PID Tuning

2.6.1. n8n Integration and PID Control Agent

To implement AI-based control operation, we used n8n (AI workflow), an open-source, low-code automation platform [38]. It allows for the flexible coordination of AI agents and RESTful API services. n8n can also integrate with custom APIs, connect with large language models (LLMs), and has built-in workflow logic that supports event-driven and conditional actions. Using this architecture, we were able to eliminate the need for complex backend scripting and interact with powerful AI agents that can be easily understood in real time. In our study, n8n acts as the orchestration layer for two AI agents: (1) PID Control Agent and (2) Optimizer Agent. The “PID Control Agent” is activated through a chat interface and works as a supervisor for “Optimizer Agent”. It can interact with human users, can retrieve the system’s performance or error metrics through a “GetMetrics” node, and can evaluate them according to requirements or set thresholds. This agent (PID Control Agent) runs on OpenAI’s o3-mini model [44]. This small reasoning model was chosen for its low cost, high intelligence, and quick performance. Our aim was to conduct frequent and rapid experiments without incurring high inference costs during testing cycles. The outline of the PID control agent in n8n is shown in Figure 3.

Based on the prompt or chat input provided, when certain conditions are met, the PID control agent determines whether the system requires further tuning. If needed, this agent can trigger the “Optimizer Agent,” through a sub-workflow.

2.6.2. Optimizer Agent

The Optimizer Agent is a callable agent that optimizes the PID parameters for multiple objectives, as defined by the parent agent’s chat input or its system prompt. This agent uses OpenAI’s GPT-4.1-mini model [45], which has good reasoning abilities and handles structured control objectives more effectively than lighter models. The Optimizer Agent begins by gathering real-time system performance metrics and the current PID settings using RESTful GET requests at the “GetMetrics” and “GetPID” nodes, respectively. Based on the system’s behavior, it uses the rationale given in the system prompt of the embedded OpenAI chat model and suggests new gain values. Then, it sends these updated parameters ($Kp$, $Ki$, or $Kd$) to the main QUBE-Servo 2 control system through the “UpdatePID” node. Communication between these workflows relies on n8n’s structured data exchange and tool chaining system, which ensures that updates happen in sync without disrupting the real-time control loop (Figure 4).

2.6.3. System Prompts

In the large language model (LLM)-based AI framework, the system prompt is a critical element that drives reasoning during operation. The prompt is read during workflow execution and sent to the underlying LLM, such as OpenAI’s o3-mini or gpt-4.1-mini. Since our goal is to control PID parameters, the prompt includes instructions to analyze the current state of the system using real-time performance metrics, such as SSE, overshoot, rise time, and settling time, along with the current PID gain values. It also provides reasoning to make decisions based on evaluation results or set thresholds that guide the operation. For example, the PID control agent’s prompt, when triggered by chat, first checks the current states of the system through the “GetMetrics” node. If the SSE exceeds 0.3 radians and the overshoot is below −30%, it sends the task to the Optimizer Agent for further fine-tuning.

The complete system prompt used in the “PID Control Agent,” which utilizes OpenAI’s “o3-mini” in the background, is provided in Appendix A.1. This prompt serves as a compact and structured communication link between real-time QUBE-Servo 2 operation and the AI agent’s reasoning engine. This ensures that the model has enough context to understand control goals, determine if tuning is necessary, and receive new gain values. The prompt in the “Optimizer Agent” is designed to manage the live servo system using nodes such as “GetMetrics,” “GetPID,” “UpdatePID,” and a set function (ToMainWorkflow) to send information back to the “PID Control Agent.” The “GetMetrics” node collects error or performance metrics calculated by the Python program after each positive square wave. As shown in Figure 4, the “GetPID” node gathers current gain values from the running system. The “UpdatePID” node sends the updated $Kp$, $Ki$, or $Kd$ values to the QUBE-Servo 2 system.

Appendix A.2 presents a system prompt that provides the AI agent (Optimizer Agent) with instructions for fine-tuning PID parameters using live feedback. We also used a different Optimizer Agent that functions without specific system prompt guidance. This agent relies on its LLM knowledge engine to adjust the PID values within set safe limits. The prompt for this agent (without system instruction) is given in Appendix A.3.

2.7. Overall Workflow

The overall PID tuning workflow using the AI agent can be described by using the flowchart shown in Figure 5. The main workflow agent (uses the o3-mini model) calls an Optimizer Agent to perform the tuning operation.

Data transfer from the AI agent to the servo system and from the servo system to the AI agent occurs through the Flask server while the system is running. The final output message explaining PID operation can also be sent back to the parent workflow (PID Control Agent). Based on this information, the PID Control Agent’s chat model block can engage in natural conversation, explain updated values of $Kp$, $Ki$, and $Kd$ applied to the physical system, and perform additional tuning if requested by the user.

3. Results

3.1. Real-Time Autonomous Tuning

This section presents the results of real-time autonomous PID tuning conducted with AI agents. We implemented two different tuning strategies for optimization, both using the gpt-4.1-mini LLM model. The Optimizer Agents can collect performance/error metrics from the live Quanser QUBE-Servo 2 system to evaluate its performance, make informed decisions, and adjust control parameters as necessary. In the first strategy, the Optimizer Agent followed specific instructions included in its system prompt, which provided guidelines for adjusting parameters (see Appendix A.2). In the second strategy, the agent has more freedom (see Appendix A.3). It only received a safe operating range for the PID gains ($Kp$: 0.1 to 2.5, $Ki$: 0 to 1.0, and $Kd$: 0 to 0.25) and was responsible for fine-tuning based on live system feedback and its own reasoning. The outcomes varied across experimental runs. However, the AI agent always stayed within safe limits and demonstrated intelligent decision-making throughout the tuning process.

3.1.1. LLM Model with Tuning Strategy

Figure 6 shows the live PID tuning process directed by system prompt guidelines (Appendix A.1). As seen in Figure 6a,b, the LLM first gradually increases the Kp value. It then reduces Kp while increasing the Ki and Kd values over time.

Figure 6c,d shows that, around 104 s, the agent finds a good set of tuned parameters and stops making more adjustments. The final optimized values for this run, which correspond to Run 2 in Table 1, were $Kp=0.125$, $Ki=0.10$, and $Kd=0.025$.

The final tuned PID values varied across different runs. Table 1 shows sample results for some of these runs. In addition to live tuning, the Optimizer Agents also generate outputs that include explanations or justifications for the tuning strategies used. For example, the AI agent returned the following output from Run 3:

“Initial PID values started with Kp=0.1, Ki=0, Kd=0, which resulted

in a high steady-state error and significant negative overshoot.

Incremental steps were taken: by increasing Kp, the SSE improved,

though overshoot stayed high.

Introducing Ki and Kd gradually while fine-tuning Kp helped move the

overshoot closer to zero and reduced SSE to around 0.05,

though initial changes were inconsistent.

Further adjustments were made by increasing Kp to improve rise time

(while monitoring overshoot) and then fine-tuning with Ki and Kd,

which led to a balanced response.

Final PID values achieved a steady-state error around 0.21 and

overshoot slightly negative but near zero, with a low rise time of

about 0.18 s. The settling time remained somewhat high, which could be due to conservative system response or minor noise effects.

Final PID values: Kp = 0.2375 Ki = 0.125 Kd = 0.0375”

3.1.2. LLM Model Without Tuning Strategy

Figure 7 shows the live PID tuning process, which is not directed by the system prompt. Figure 7a,b shows that the AI agent increased the PID parameters gradually at the beginning. After analyzing some of the performance metrics, it increased Kp more than Ki and Kd values, and, at around 42 s, it finds the optimized fine-tuned values.

We observed that, when the AI agent operated without a tuning strategy, it typically found optimal parameters relatively fast (e.g., 50 to 80 s). However, in some cases, it aborted the tuning process, indicating “system instability” or “still room for improvement”. For example, in one failed run (without a tuning prompt/strategy), the Optimizer Agent returned the output shown in Appendix B.1. Table 1 shows PID tuning results for three experimental runs with and without system prompt instructions.

Table 1. PID fine-tuning results with and without system prompt instructions.

	Fine Tuning—System Prompt			Fine Tuning—Without System Prompt
Run	Kp	Ki	Kd	Kp	Ki	Kd
Run 1	0.3375	0.175	0.0750	0.35	0.10	0.10
Run 2	0.1250	0.10	0.0250	0.80	0.125	0.05
Run 3	0.2375	0.125	0.0375	0.35	0.10	0.10

Note: Each row shows PID gains obtained from different experimental runs.

Table 1. PID fine-tuning results with and without system prompt instructions.

	Fine Tuning—System Prompt			Fine Tuning—Without System Prompt
Run	Kp	Ki	Kd	Kp	Ki	Kd
Run 1	0.3375	0.175	0.0750	0.35	0.10	0.10
Run 2	0.1250	0.10	0.0250	0.80	0.125	0.05
Run 3	0.2375	0.125	0.0375	0.35	0.10	0.10

Note: Each row shows PID gains obtained from different experimental runs.

3.2. Overall Performance

Figure 8, Figure 9 and Figure 10 show the system’s performance during the tuning process in experimental Run 3 (Table 1). The system showed similar behavior in the other experimental runs where a final fine-tuned value was determined. In Figure 8a,b, it is clear that both tuning methods, whether guided by system prompts or not, were effective in reducing the Integral Absolute Error (IAE) and Integral Squared Error (ISE).

Figure 9a,b shows that both PID tuning strategies (with or without system prompts) successfully lowered the Mean Absolute Error (MAE) and Root Mean Squared Error (RMSE).

Figure 10a,b shows how Integral Time-Weighted Absolute Error (ITAE) and Integral Time-Weighted Squared Error (ITSE) changed during the tuning process. These metrics focus more on errors that happen in later stages due to small oscillations.

3.3. Human Interaction with the System

This section demonstrates the human–machine interaction (HMI) aspect of the study and how the integration of agentic AI reshapes the way that users interact with a control system. For example, in situations where a human user watches how the system behaves and makes qualitative assessments, an LLM-based output is more intuitive than traditional tuning approaches. In our sample runs, when the LLM produced outputs such as, “Current tuning attempts lowered SSE but caused unacceptable overshoot. Gains kept increasing, yet system stability remains doubtful. Recommend aborting tuning to prevent instability.” or “It feels too jittery when approaching the setpoint,” it conveys more than just whether the controller succeeds or fails. Classical or modern controllers lack the ability to interpret such statements or determine subsequent actions. Additionally, without agentic AI integration, having only an LLM in the loop, a control engineer would need to observe system performance and interpret outputs, such as “recommend aborting tuning to prevent instability” or “jittery,” into a manual technical adjustment.

Figure 11 presents an example of HMI for a sample run without a tuning strategy. Initially, the agent determined the optimal values of $Kp$, $Ki$, and $Kd$ as $0.22$, $0.1$, and $0.02$, respectively. When the AI agent was asked why it lowered the Kp value during operation, it provided a detailed explanation (Figure 11).

Figure 12 and Figure 13 illustrate two additional interactions, where the questions posed were, “If the load torque increases by 10%, how should the controller change?” and “What if the sampling rate is doubled? Do you think it is a good idea for the current system?” These examples demonstrate that the AI agent interacts with a human user and can provide suggestions for improvement, such as, “Would you like to simulate this adjustment using our optimizer sub-workflow to see what updated PID parameters might look like for the increased load?”

The complete responses from the AI agent corresponding to Figure 11, Figure 12 and Figure 13 are provided in Appendix C.1.

3.4. Video Demonstration

This section shows two video demonstrations of experimental runs (

Table 2. Video demonstrations of real-time PID tuning experiments.

Video	Link
Video 1	https://drive.google.com/file/d/1OD_wtOu5WGKWhlSoacgME-8QdfR5AGtZ/view?usp=sharing (accessed on 15 September 2025)
Video 2	https://drive.google.com/file/d/1hIQhX_PGSJ4vXkFlxAPIH54zEdsQdcDN/view?usp=sharing (accessed on 15 September 2025)

). Video 1 shows real-time PID tuning of the servo system using the prompt from Appendix A.2 for the Optimizer Agent. In Video 2, the prompt from Appendix A.3 is used, allowing the model greater freedom to fine-tune parameters within a safe range. After the tuning process, the Optimizer Agent produced a text response and sent it to the main PID control workflow, which is included at the end of each video.

4. Discussion

To assess the effectiveness of agentic AI-based PID tuning with LLMs, we conducted experiments on the Quanser QUBE-Servo 2 platform. We compared two modes of agentic operation: one where the AI model (gpt-4.1-mini) received structured guidance in the system prompt and another without such prompt instructions. Both agents iteratively adjusted the PID gains ($Kp$, $Ki$, and $Kd$ values), as outlined in several sample runs in Table 1. We analyzed the results found in one of the runs (Run 3) using various time-domain error metrics: IAE, ISE, MAE, RMSE, ITAE, and ITSE. Other experimental runs showed similar performance, except in a few cases (about 1 out of 10 runs) where the AI operating without a system prompt instruction failed to produce a final PID value. An example of such a failed output is provided in Appendix B.1.

Figure 8a,b shows the changes in IAE and ISE over time as tuning progresses. The AI agents with or without the system prompt’s tuning strategy consistently produced lower error values after the initial transient phase. Although both setups displayed similar peak error early in the process (around 20 s), they quickly reached a more stable and lower error state.

Similarly, Figure 9a,b, which shows MAE and RMSE, outlines a rapid decline in error in both cases, after which both stabilize at lower values. The RMSE metric, which heavily penalizes large deviations, shows the good stability of the tuned controller. The peaks seen in the system without prompt instructions indicate periods of less effective tuning and transient oscillations.

Figure 10a,b highlights the time-weighted error accumulation through ITAE and ITSE. These metrics emphasize the importance of minimizing long-term errors. Although both tuning methods start at similar levels, the controller tuned with system prompt instructions shows flatter ITAE growth trends by the end of the experiment. Here, ITAE and ITSE both exhibited an increasing trend due to device sensitivity. In high-performance systems like the QUBE-Servo 2, small oscillations near the settling point can produce significant time-weighted accumulated errors later in operation. This problem can be mitigated by using a more guided control method, such as classical PD control or proportional-plus-rate feedback. This also indicates that even slight signal noise in the servo can cause the derivative term to behave erratically. By design, ITAE and ITSE metrics penalize long-lasting, late-stage oscillations more than early or transient deviations. In our experiments, even when IAE, ISE, MAE, and RMSE decreased significantly (showing strong average control), the small ripples near the setpoint accumulated over time, causing ITAE and ITSE to remain comparatively high. This does not necessarily indicate poor control performance overall, but rather that the QUBE-Servo 2’s residual noise and oscillatory behavior dominate these time-weighted measures. A further refinement of the filter constant (Td) or more conservative derivative tuning could mitigate those tiny oscillations near the setpoint (i.e., improve ITAE and ITSE). However, there is a trade-off: too much filtering slows response (not suitable for live tuning) and reduces the derivative’s stabilizing benefit.

The differences in PID gains in various runs illustrate the tuning behavior of agents. The system prompt led the agent to choose a more conservative Kp (0.2375 compared to 0.35) and a much lower Kd (0.0375 versus 0.10). With structured instructions (e.g., Appendix A.2), the optimizer followed a stepwise procedure that produced more conservative and stable parameter updates. In contrast, without such guidance (Appendix A.3—“Step 1: Use your knowledge to fine-tune Kp, Ki, and Kd values”), the LLM relied on its own internal knowledge to infer tuning strategies within the safe operating range. While this unguided reasoning allowed for faster or aggressive adjustments, it also introduced greater variability in the final tuning outcomes.

Section 3.3 shows that AI agent can parse informal user queries and infer their meaning in the context of control engineering. For example, in one test, the AI agent recommended “aborting tuning to prevent instability”. In another test, it responded with an explanation and a plan: “I noticed the system is oscillating at the setpoint, showing jittery behavior. This might happen because the derivative term is amplifying noise. I will reduce Kd slightly to smooth the response.” This kind of ability to interpret descriptions and connect them to control concepts offers significant potential for applications within human–robot interaction (HRI) and broader human–machine interaction [46]. Beyond interpreting system performance, such approaches can also reduce the dependence on specialized technical or programming expertise. For example, Vemprala et al. showed that ChatGPT can interpret user commands and generate corresponding robot control code, while also enabling iterative refinement through dialogue [47].

Some recent studies offer critical perspectives on the use of LLMs, cautioning about the validity of the chain-of-thought, the scalability of retrieval-augmented generation (RAG), and the reliability of LLM outputs in programming [48,49,50]. However, we would like to highlight that our framework is fundamentally different from retrieval-augmented generation (RAG) and open-ended LLM applications. Instead of retrieving unstructured documents from a knowledge base, our system continuously grounds the LLM to real-time control metrics obtained from the live servo motor. Using the n8n workflow, these control metrics (e.g., IAE, ITSE, overshoot, settling time) are directly linked to the physical system. This approach ensures that the LLM’s recommendations are always constrained by measurable outcomes, unlike RAG systems, which are dependent on retrieval quality and the semantic interpretation of external text. In this way, our method uses feedback-based grounding instead of retrieval-based grounding, making it more reliable for real-time PID tuning.

The use of AI agents also makes the control system more transparent and user-friendly. It can provide natural-language explanations for why certain gains were chosen or changed. Consider the following output: “Increased $K_p$ from 1.5 to 1.8 to reduce steady-state error, as the system was settling below the target. Slightly decreased $K_d$ to 0.2 to avoid amplifying noise, given the observed small oscillations.” This kind of rationale is incredibly valuable in practice; it is essentially the controller documenting its reasoning in a way that a human operator (or even a non-expert) can understand. Traditional tuning methods provide no such feedback.

In this study, the agentic AI framework serves as an advisor or expert, capable of explaining the tuning process. Users can question the controller’s decisions and receive meaningful responses, transforming the system from a black box into an interactive assistant for control.

5. Conclusions

This study introduces a novel method for real-time PID tuning by using large language models (LLMs) on a live control framework. We presented that an LLM can directly interact with a physical servo motor, the Quanser QUBE-Servo 2, by guiding a tuning process. The AI agent had two modes: one driven by a structured system prompt and the other based on safe ranges of PID values without specific instructions. Both tuning strategies produced good results in lowering performance metrics such as IAE, ISE, MSE, and RMSE. However, they were less effective in reducing ITAE and ITSE. This was primarily due to the high-frequency oscillations and noise in the control system, especially during long run times. Although reducing tiny oscillations at the end to improve ITAE and ITSE is possible through stronger filtering or conservative derivative tuning, it comes with the trade-off of slower response, which limits suitability for live tuning.

The live video demonstrations of agentic PID control (Section 3.4) highlights the potential of LLM-driven agents in bridging high-level AI reasoning to low-level, real-time control tasks. While traditional AI-based control often relies on off-line training or human-in-the-loop or model-based approaches, this study is the first known attempt to use LLMs for the direct, real-time control of a physical system and confirms the practical viability of agentic AI.

This work investigates the role of LLMs not just as tools for optimization but also as interactive agents in control engineering. They can adjust parameters in real time while allowing natural language interaction with the operator. This ability tackles two persistent issues in both traditional and modern control methods: (i) the lack of clear communication and dialogue between the controller and the human, and (ii) the challenge in adjusting to disturbances or changing environments without needing specialized skills. Our study demonstrated that LLMs can serve as both a tuning engine and a human–machine interface, paving the way for a new approach to human-centered control.

Future research in this area should incorporate usability studies of human–machine interaction, different prompting strategies, LLM training, and integration methods to improve system usability, reliability, and performance. Overall, this work is an important step in integrating heuristic, language-based reasoning into real-time machine control systems.