Task-Aware Digital Twin State Updates in Resource-Constrained Edge IoT

1. Introduction

Today, a digital twin is regarded as a software representation of a physical entity that reflects its properties, behavior, and changes throughout its lifecycle [1,2]. Such a representation requires a continuous connection with the physical object, regular state updates, and the ability to model and predict system behavior under different conditions.

In studies on digital twins in the IoT context [3,4], synchronization between physical and digital objects is considered one of the fundamental characteristics of a full-fledged digital twin, and the effectiveness of this connection directly depends on the timeliness of state updates. The development of IoT, IIoT, and edge systems makes maintaining an up-to-date digital twin state particularly important. Modern digital twins [5] operate in environments with distributed data sources, variable workloads, heterogeneous network conditions, and limited computing resources.

Studies on network digital twins [6,7] show that the role of a digital twin is not limited to reflecting the state of a network or system, but also includes support for real-time analysis, what-if scenarios, planning, diagnostics, and optimization.

A key layer in such solutions is the edge layer [8], where some digital twin functions are moved closer to the data source to reduce latency, improve local responsiveness, and decrease dependence on the central cloud [9]. At the same time, edge nodes have more limited processor time, memory, energy, and bandwidth resources than cloud environments. Therefore, increasing the frequency and granularity of updates can improve the potential accuracy and freshness of the model [7,10], but simultaneously increases network and computational costs.

Studies of dynamic hierarchical digital twin synchronization [11] show that synchronization is not a universal procedure for all application tasks. Different tasks depend differently on update timeliness, data reliability, and the degree of digital twin state staleness.

Therefore, the update intensity should be determined by considering both the arrival of new data and the value of a particular update for the current task. This creates a need for a method that, in each cycle, balances digital-state quality with the resources available at the edge node.

Digital twins are increasingly used in real-time systems, while part of their functionality is being transferred to resource-constrained edge nodes. Under these conditions, balancing the accuracy and freshness of the digital representation with the available network and computing resources becomes particularly important. Therefore, developing a method for managing digital twin state updates is a relevant research direction.

1.1. Research Gap

A literature review shows that existing studies examine individual aspects of digital twin synchronization and maintenance in considerable depth, but mostly in isolation. In bandwidth-limited synchronization studies [12], traffic is reduced by allowing a permissible deviation between physical and digital states and by accounting for an error tolerance acceptable for the application task.

Another line of research focuses on update timeliness and state staleness under budget or energy constraints. Such approaches minimize staleness or maximize digital-state freshness under a fixed synchronization budget [13,14]. Joint optimization of Age of Information and energy efficiency is also studied [15], together with delay-aware synchronization using semantic communications [16].

In studies [17,18,19,20], the digital twin is used to support model retraining, query execution, computational task allocation, and edge-infrastructure resource management. In digital twin migration studies [21], placement decisions are linked to synchronization delay and resource availability. At the same time, data-fusion studies [22] focus on reconciling heterogeneous data sources with digital-representation requirements.

A comparison of these works shows that they cover individual aspects of the problem but do not form a unified decision-making policy for each step. Such a policy should simultaneously determine the state component, detail level, processing location, and whether transmission is warranted, while accounting for the priority of the application task and the specified resource constraints. The main differences between the reviewed approaches and the proposed method are summarized in Table 1.

Thus, existing approaches do not fully cover the problem of managing digital twin state updates on a resource-constrained edge node. Within a single cycle, such an approach should determine which component to update, when to update it, at what detail level, and where processing should take place. The decision should balance the expected improvement in digital-state quality against resource costs. Therefore, the following study focuses on formalizing this problem and experimentally validating the proposed approach.

1.2. Research Aim

The aim of the study is to develop a method for managing digital twin state updates on a resource-constrained edge node. The method should support adaptive decisions regarding the composition, timing, location, and detail level of updates while accounting for the application task, requirements for freshness and accuracy of the digital representation, and available resources.

1.3. Research Objectives

• Analyze existing approaches to synchronization and digital twin state updates in IoT, edge, and edge-cloud environments and identify their limitations with respect to task-aware update management.
• Develop a digital twin state model and define indicators of staleness, error, application-task utility, and the resource cost of updating.
• Formulate the mathematical problem of managing digital twin state updates while accounting for the application task and resource constraints.
• Develop a one-step heuristic method for adaptive selection of state components, detail levels, and update-processing locations.
• Define experimental evaluation metrics independent of the control criterion, including state MAE/RMSE, event-preservation accuracy, serialized data volume, computational cost, state staleness, and selector runtime.
• Conduct a laboratory validation of the proposed method using physical telemetry and compare it with a baseline periodic policy and a freshness-maintenance policy under resource constraints on the same data sequence.

1.4. Research Hypothesis

The research hypothesis is that adaptive update management can provide a better balance between digital-state freshness and resource costs. Update decisions should account for the application task, component importance, current staleness, expected quality gain, detail level, and processing location. The expected outcome is not to outperform simple baseline policies in every individual metric, but to allocate resources among digital twin state components according to the current task.

1.5. Scientific Novelty and Main Contributions

The scientific novelty of the study lies in formalizing digital twin state updating as a control problem oriented toward the current application task. Update decisions are made based on the expected gain in digital-representation quality and the normalized resource cost of an admissible update option, rather than solely upon arrival of new data or at fixed time intervals.

The main contributions of this work are as follows:

• a multicomponent digital twin state model is proposed, in which component quality depends jointly on discrete staleness and error relative to the current reference value;
• a generalized resource-constrained update problem is formulated and explicitly separated from its practical one-step heuristic solution;
• a task-aware priority rule ηᵢ(t)ΔUᵢrl(t)/Cᵢrl(t) is developed, combining component weight, quality gain, urgency, and normalized network and computational costs;
• physical semantics are implemented for low/medium/high detail levels and sensor/edge processing locations: quantization can be performed on the ESP32 before transmission or at the edge node after transmitting the raw value;
• actual omission of fields in HTTP/JSON is implemented, together with a next-cycle feedback policy, zero-order-hold prediction used only for scoring omitted temperature and humidity values, and a safety override for an active shock event;
• the method is compared on a single 180-cycle physical trace using metrics independent of task_utility and two budget-consistent baseline policies.

The experimental results show that the proposed method can reduce network and computational costs in several task/budget configurations while preserving low staleness for prioritized components. At the same time, the critical event-oriented configuration reveals a starvation limitation for slowly changing components, which defines an important boundary of the current heuristic.

2. Materials and Methods

2.1. Mathematical Problem Formulation

Consider a digital twin that maintains an estimate of the physical-object state at discrete time steps t = 1, 2, ..., T. Let the physical state be described by the vector

$$\mathrm{s}\left(\mathrm{t}\right)=\left({\mathrm{s}}_1\left(\mathrm{t}\right),{\mathrm{s}}_2\left(\mathrm{t}\right),\dots ,{\mathrm{s}}_{\mathrm{M}\left(\mathrm{t}\right)}\right),$$

(1)

where sᵢ(t) is the i-th state component, i = 1, ..., M, and the digital twin state is represented by the estimate

$$\mathrm{ŝ}\left(\mathrm{t}\right)=\left({\mathrm{ŝ}}_1\left(\mathrm{t}\right),{\mathrm{ŝ}}_2\left(\mathrm{t}\right),\dots ,{\mathrm{ŝ}}_{\mathrm{M}\left(\mathrm{t}\right)}\right).$$

(2)

For each component i, a set of detail levels Rᵢ and a set of possible processing locations Lᵢ are introduced [21]. The binary variable xᵢrl(t) ∈ {0,1} denotes selection of an update for component i with detail level r ∈ Rᵢ at location l ∈ Lᵢ. For each component, no more than one active option is allowed at a given step:

$${\mathsf{\Sigma }}_{\left\{\mathrm{r}\in \mathrm{R}\mathrm{ᵢ}\right\}}{\mathsf{\Sigma }}_{\left\{\mathrm{l}\in \mathrm{L}\mathrm{ᵢ}\right\}}\mathrm{x}\mathrm{ᵢ}\mathrm{r}\mathrm{l}\left(\mathrm{t}\right)\le 1,\forall \mathrm{i},\mathrm{t}.$$

(3)

For each component, an internal discrete staleness indicator aᵢ(t) ≥ 0 is introduced. It equals the number of cycles since the last actual update of that component in the digital twin. Unlike the classical network Age of Information (AoI) metric [23], this indicator does not separately account for data generation time, transmission time, or queueing time. Therefore, it is used here as an internal discrete state-staleness indicator rather than as a complete network information-age metric.

$$\mathrm{a}\mathrm{ᵢ}\left(\mathrm{t}+1\right)=0 \mathrm{i}\mathrm{f} \mathrm{t}\mathrm{h}\mathrm{e} \mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{o}\mathrm{n}\mathrm{e}\mathrm{n}\mathrm{t} \mathrm{i}\mathrm{s} \mathrm{a}\mathrm{c}\mathrm{t}\mathrm{u}\mathrm{a}\mathrm{l}\mathrm{l}\mathrm{y} \mathrm{u}\mathrm{p}\mathrm{d}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{d}; \mathrm{a}\mathrm{ᵢ}\left(\mathrm{t}+1\right)=\mathrm{a}\mathrm{ᵢ}\left(\mathrm{t}\right)+1 \mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}.$$

(4)

The state error is defined as εᵢ(t)=dᵢ(zᵢ(t), ŝᵢ(t)), where zᵢ(t) is the reference value available for decision-making. If a new T/H value is transmitted, zᵢ(t) equals the received telemetry. If a numerical component is omitted by the transmission policy, a zero-order-hold estimate zᵢ(t)=xᵢ(t_last), i.e., the last value available to the edge node, is used for predictive scoring. This estimate is not treated as a new measurement and does not reset aᵢ(t). For shock_event, the absence of the field is interpreted as a current false observation for scoring, but likewise does not update the stored twin state.

The detail level is defined by the quantization operator Qᵢʳ(·). For an update candidate, the predicted state and error at the next step are defined as

$$\widehat{s_i}\left(t+1∣r\right)=Q_i^r\left(z_i\left(t\right)\right)$$

(5)

$${\mathsf{\epsilon }}_i\left(t+1∣r\right)=d_i\left(z_i\left(t\right),Q_i^r\left(z_i\left(t\right)\right)\right)$$

(6)

$$a_i\left(t+1∣r\right)=0$$

(7)

For the no-update option, the digital state is held while staleness increases:

$$\widehat{s_i}\left(t+1∣0\right)=\widehat{s_i}\left(t\right)$$

(8)

$${\mathsf{\epsilon }}_i\left(t+1∣0\right)=d_i\left(z_i\left(t\right),\widehat{s_i}\left(t\right)\right)$$

(9)

$$a_i\left(t+1∣0\right)=a_i\left(t\right)+1$$

(10)

The quality of the digital representation of the i-th component is defined by the function

$$f_i\left(t\right)={\displaystyle \frac{1}{1+a_i\left(t\right)}}\max \left\{\mathrm{0,1}-{\displaystyle \frac{{\mathsf{\epsilon }}_i\left(t\right)}{{\mathsf{\epsilon }}_i^{max}}}\right\}$$

(11)

where ${\epsilon }_i^{max}$is the normalization value for the error of the corresponding component. The function fᵢ(t) takes values in the range [0,1] and decreases as both staleness and digital-representation error increase.

Let application task q(t) be active at time t, with component-importance weights wᵢ(q(t)) ≥ 0, Σᵢ wᵢ(q(t))=1. Then the task-aware state utility is defined as

$$U_{\mathrm{task}}\left(t\right)={\displaystyle \sum _{i=1}^M}{w}_i\left(q\left(t\right)\right)f_i\left(t\right)$$

(12)

For each admissible decision (i,r,l), the general formulation assigns resource characteristics dᵢrl — transmitted data volume, cᵢrl — computational cost, eᵢrl — energy cost, and τᵢrl — update latency [24]. The total costs can be written as

$$C_{\mathrm{net}}\left(t\right)={\displaystyle \sum _{i=1}^M}\sum _{r\in R_i}\sum _{l\in L_i}{d}_{irl}{x}_{irl}\left(t\right)$$

(13)

$$C_{\mathrm{cpu}}\left(t\right)=\sum _{i=1}^M\sum _{r\in R_i}\sum _{l\in L_i}{c}_{irl}{x}_{irl}\left(t\right)$$

(14)

$$C_{\mathrm{en}}\left(t\right)=\sum _{i=1}^M\sum _{r\in R_i}\sum _{l\in L_i}{e}_{irl}{x}_{irl}\left(t\right)$$

(15)

$$C_{\mathrm{delay}}\left(t\right)=\sum _{i=1}^M\sum _{r\in R_i}\sum _{l\in L_i}{\mathsf{\tau }}_{irl}{x}_{irl}\left(t\right)$$

(16)

In general, the system is subject to the constraints Cnet(t)≤B(t), Ccpu(t)≤P(t), and Cen(t)≤E(t). The generalized planning-horizon problem can be written as

$$max\sum {\left(t=1\right)}^T\left[U_{\left(task\right)}\left(t\right)-{\lambda }_1{C}_{\left(net\right)}\left(t\right)-{\lambda }_2{C}_{\left(cpu\right)}\left(t\right)-{\lambda }_3{C}_{\left(en\right)}\left(t\right)-{\lambda }_4{C}_{\left(delay\right)}\left(t\right)\right]$$

(17)

This formulation defines the overall control objective, but the proposed method does not solve it exactly over the entire horizon. Instead, a practical decision is formed at each step using a one-step local-best + greedy heuristic rule. Therefore, the resulting solution does not guarantee the global optimum of the formulated multi-step problem.

2.2. Method for Managing Digital Twin State Updates

The proposed method is intended to manage updates of a multicomponent digital twin state under limited edge-node resources. Unlike full or fixed-periodic synchronization, the method determines in each cycle which components should be transmitted and updated, at what detail level, and where quantization should be performed — sensor-side or edge-side.

The software implementation distinguishes three stages: physical measurement, network transmission, and digital twin state update. The sensor node physically measures variables in every cycle, but the HTTP/JSON packet contains only the fields allowed by policy π(t) received from the edge node in the previous cycle. After receiving the packet, the edge node updates only the components that were actually transmitted, computes the next decision π(t+1), and returns it to the sensor node in the HTTP response. Thus, a decision formed at step t physically affects transmission at step t+1. The resulting measurement-transmission-update cycle is illustrated in Figure 1.

For the numerical components temperature and humidity, three detail levels are defined: low, medium, and high. In the laboratory implementation, low means rounding to 1 measurement unit, medium to 0.1, and high to 0.01. For location=sensor, quantization is performed on the ESP32 before the JSON is formed, whereas for location=edge the sensor transmits a raw value with two decimal places and quantization is then performed at the edge node. For shock_event, only binary/sensor is used, because the discrete low/medium/high levels have no physical meaning for a binary event.

If temperature or humidity is not transmitted, the current twin_value is retained and aᵢ increases by one cycle. The last available value is used only as a zero-order-hold prediction for candidate evaluation and does not replace an actual update of the digital twin state.

A separate rule applies to shock_event. If an active shock event is detected locally, the emergency override is triggered, so shock_event is transmitted regardless of the previous send=false decision. The cost of such transmission is accounted for separately and may temporarily exceed the planned resource budget.

For each admissible candidate, the expected gain in quality and task-aware utility is computed:

$$\mathsf{\Delta }{f}_{\left(irl\right)}\left(t\right)=f_i\left(t+1∣r\right)-f_i\left(t+1∣0\right),\hspace{1em}\mathsf{\Delta }{U}_{\left(irl\right)}\left(t\right)=w_i\left(q\left(t\right)\right)\mathsf{\Delta }{f}_{\left(irl\right)}\left(t\right)$$

(18)

Update urgency is defined by the coefficient

$${\mathsf{\eta }}_i\left(t\right)=1+\min \left\{{\displaystyle \frac{a_i\left(t\right)}{8}},1\right\}+g_i\left(t\right)$$

(19)

For temperature, the normalized change gᵢ(t) is defined relative to 0.10 °C, and for humidity relative to 0.50%. If a numerical component is not transmitted, gᵢ(t)=0 because no new measurement is available to the edge node for estimating the change. For shock_event, gᵢ(t)=1 if the binary state changes or the current observation is true, and gᵢ(t)=0 otherwise. For an active shock_event, an additional 2.5 is added to ηᵢ(t), increasing the priority of a hazardous event.

In the generalized model, priority may account for d, c, e, and τ. In the experimental implementation, only physically calibrated d and c are used for ranking. Energy consumption was not included because no hardware meter was available, while HTTP RTT was treated as a system-level characteristic of the entire transmission cycle rather than as a separate delay associated with a specific candidate. The normalized candidate cost is defined as

$$C_{\left(irl\right)}\left(t\right)=0.5{\displaystyle \frac{d_{\left(irl\right)}}{B\left(t\right)}}+0.5{\displaystyle \frac{c_{\left(irl\right)}}{P\left(t\right)}}$$

(20)

and the one-step priority as

$${\mathsf{\Phi }}_{\left(irl\right)}\left(t\right)={\displaystyle \frac{{\mathsf{\eta }}_i\left(t\right)\mathsf{\Delta }{U}_{\left(irl\right)}\left(t\right)}{C_{\left(irl\right)}\left(t\right)}}$$

(21)

In the experiment, λ_d=0.5, λ_c=0.5, while λ_e=0 and λ_τ=0. The energy and time components remained part of the general formulation but were not used in experimental candidate ranking because they were not directly measured.

2.3. Method Algorithm

The algorithm operates cyclically. Inputs include the current payload, digital twin state, internal staleness aᵢ(t), task profile q(t), weights wᵢ(q), candidate catalog, and planned budgets B(t), P(t). The output is next_policy π(t+1), which determines transmission in the next cycle.

• Receive the HTTP/JSON packet formed by the sensor node according to policy π(t).
• Update only those digital twin components whose fields are actually present in the payload; increase aᵢ(t) for omitted components.
• Form current_observations for scoring; for omitted T/H values, use zero-order-hold of the last available value without updating twin_value.
• Determine the current task profile q(t) and weights wᵢ(q).
• Form the candidate set: for T/H, three detail levels at two processing locations; for shock_event, binary/sensor.
• Reject candidates that individually do not fit within the planned budgets B and P.
• For each admissible candidate, evaluate the predicted post-update state, ${\epsilon }_i\left(t+1∣r\right),\hspace{1em}{f}_i\left(t+1∣r\right)$, the no-update quality $f_i\left(t+1∣0\right)$, and the gain ΔUᵢrl.
• Compute ηᵢ(t), the normalized cost Cᵢrl(t), and priority Φᵢrl(t).
• For each component, select the locally best candidate with positive priority.
• Sort the local winners in descending order of Φᵢrl(t).
• Sequentially add candidates to the plan while the accumulated d and c remain within B and P.
• Set send=false for unselected components; for selected components, record detail and location.
• Return next_policy π(t+1) to the sensor node in the HTTP response and store the diagnostic log.
• In the next cycle, the sensor node physically applies π(t+1).
• If an active shock_event is present, apply the safety override regardless of send=false; account for emergency costs separately from the planned budget.

The complete decision sequence of the proposed method is summarized in Figure 2.

2.4. Decision Rule and Method Properties

The method does not perform an exhaustive search over all combinations of xᵢrl. First, all admissible candidates for each component are evaluated and a local winner is selected; then, no more than M local winners are sorted by priority and sequentially added to the plan while checking cumulative resource use. If K=Σᵢ|$𝒞$ᵢ| is the total number of candidates and M is the number of components, the time complexity of one decision is O(K+M log M), and the memory complexity is O(K+M).

This approach is suitable for fast one-step control but does not guarantee a global optimum for the multi-step problem. In addition, the absence of a separate anti-starvation constraint means that under an extremely tight budget and a very high task weight for one component, other components may remain without updates for a long time. This property is explicitly evaluated in the experimental section and considered when interpreting the results.

2.5. Experimental Validation of the Digital Twin State Update Management Method

The experimental validation was designed to assess consistency between the software implementation and the mathematical logic of the method, and to evaluate the actual impact of detail, location, and send on data transmission and the digital twin state. The proposed policy was also compared with simpler baseline approaches on the same physical data sequence. For all compared conditions, the final protocol used a single shared physical reference trace and deterministic replay, ensuring the same input data sequence for each policy.

The laboratory testbed included an ESP32 TM-ESP32-096OLED sensor node, an AHT10 temperature and humidity sensor, and a shock switch for registering mechanical events. The sensor node operated with a period of approximately 2 s and communicated with the Linux edge node over Wi-Fi using HTTP POST. The edge-node software module maintained the digital twin state, performed one-step selection, and returned next_policy in the HTTP response. The testbed configuration is summarized in Table 2.

2.6. Model and Experimental Implementation Parameters

Two task profiles assigned different importance to the components. The event_monitoring profile gave the highest weight to shock_event, whereas comfort_monitoring prioritized temperature and humidity. Error normalization used ε_max=0.5 °C for temperature, ε_max=0.5% for humidity, and ε_max=1 for shock_event. The T/H detail levels had direct physical meaning through value rounding. The principal model and experimental parameters are listed in Table 3.

In this experiment, B is the maximum total number of candidate-specific serialized JSON bytes for planned synchronization per cycle, and P is the maximum total candidate-specific computational work per cycle. For location=edge, c includes preparation of the raw field on the ESP32 and the corresponding edge-side quantization, so it is an aggregated characteristic of computational work at both ends rather than a measure of load on a single processor. The value d excludes HTTP/TCP/IP headers and therefore characterizes only the payload increment associated with the candidate.

The d and c values were calibrated in separate tests. For d, the actual serialized JSON-field length within the operating value range was used; for c, median candidate-specific measurements of preparation/serialization time were used, with an additional quantization benchmark on the edge node for edge candidates. Energy consumption was not measured because no hardware current/power meter was available, so it was not replaced with modeled values in the final experiment. The calibrated candidate-specific costs are reported in Table 4.

2.7. Data Collection and Comparison Protocol

For the final validation, one continuous physical reference trace of 180 consecutive cycles was collected. The serial logger recorded GT_JSON for each cycle, including raw temperature, raw humidity, reference shock_event_raw, as well as CPU and RTT diagnostics. The seq=551–730 sequence was complete: 180/180 cycles with no gaps. The first cycle, seq=551, was used as a common bootstrap initialization, so all comparative metrics were calculated over the same 179 cycles, seq=552–730.

During physical data collection, a real ESP32→HTTP→edge feedback loop was active. For controlled comparison, all scenarios used the same physical reference trace. Based on this trace, six configurations of the proposed method were replayed separately, corresponding to two task profiles and three resource-budget levels. This eliminates the influence of different sequential physical phases: all policies observe the same sequence of changes in T, H, and shock.

Two baselines were implemented for comparison. The Periodic baseline does not use task weights or ΔU: under the normal budget, T+H+shock are updated every cycle; under the limited budget, T+shock and H+shock alternate; under the critical budget, one of the three components is updated cyclically. The Freshness-only baseline ignores the task profile and change magnitude, ranks components only by aᵢ(t), uses high/edge for T/H and binary/sensor for shock, and sequentially adds candidates to the plan within the same B/P budgets. When age values are equal, the deterministic order shock_event, temperature, humidity is applied. In both baselines, an active shock_event uses the same safety override as the proposed method.

The main outcome metrics were MAE and RMSE between raw reference T/H and the current twin_value, precision/recall/F1 for the stored shock_event state relative to reference shock_event_raw, mean actual d and c, maximum aᵢ, and the number of planned-budget violations. Task_utility was used only as an internal control criterion and was not the primary performance metric.

3. Results

3.1. Experimental Results

The resulting accuracy metrics for all compared policies are summarized in Table 5.

As shown in Figure 3, resource costs depend on both the assigned budget and the application-task profile. Under the normal budget, the adaptive policy for both profiles achieved an average network cost of 54.00 B/cycle and computational cost of 275.077 µs/cycle, whereas the baseline policies required 57.00 B/cycle and 309.144 µs/cycle, respectively. Under the limited budget, the event-monitoring profile produced lower costs, while the comfort-monitoring profile had the same network cost but higher computational cost than the baselines. This indicates that the proposed method does not provide the same resource gain in all modes; its behavior depends on the priorities of the current application task.

Figure 4 shows that reducing resource cost does not always reduce digital-state error. For temperature, differences between the policies remain relatively small, whereas for humidity the adaptive policy has higher MAE in some modes than the baseline policies. At the same time, it provides lower or comparable network cost depending on the task profile and resource budget. Thus, the proposed method does not minimize error or resource cost in isolation, but rather forms a trade-off among digital-state accuracy, resource cost, and the priorities of the current application task.

In five of the six adaptive scenarios, the stored shock_event state achieved F1=1.0000. For comfort_monitoring/critical, F1 decreased to 0.8678 because of 32 false-positive cycles following a previous true state: when the false field was not transmitted, the stored twin_value remained true for some time. At the same time, FN=0 in all adaptive and baseline scenarios, meaning that no active shock_event in this trace was lost due to the emergency override. This result characterizes event preservation in the protocol rather than the accuracy of an independent classifier, because reference shock_event_raw is generated by the same threshold logic of the sensor.

Resource cost, staleness, and planned-budget compliance for the compared scenarios are summarized in Table 6.

The planned policy had 0 B/P budget violations in all 12 scenarios. Exceedances of actual cost in some critical/limited cycles were caused exclusively by emergency shock transmission. Therefore, B and P are treated as budgets for planned synchronization, whereas emergency safety traffic has higher priority and is accounted for separately in the statistics.

Under the normal budget, the adaptive policy in both task profiles used an average of 54.00 B/cycle and 275.077 µs/cycle versus 57.00 B and 309.144 µs for the periodic/freshness baselines, i.e., approximately 5.26% lower d and 11.02% lower c. This saving was accompanied by higher humidity error because the adaptive selector systematically chose the cheaper low/sensor candidate.

Under the limited budget, the event_monitoring profile reduced d by approximately 3.97% and c by 10.38% relative to both baselines while maintaining max age=1 for T/H. In contrast, comfort_monitoring/limited provided no saving in d and used approximately 15.32% more c than the baselines. This shows that the proposed method does not outperform simpler policies on every individual metric but provides task-dependent resource reallocation.

Under the critical budget, comfort_monitoring achieved 25.96 B/cycle and 106.680 µs/cycle. Relative to freshness-only, this corresponds to approximately 11.73% lower d and 19.30% lower c, but at the cost of higher humidity error and F1=0.8678. The most extreme event_monitoring/critical mode used only 20 B/cycle and 22 µs/cycle; however, temperature and humidity were not updated during all 179 evaluated cycles, so max age reached 179 for both. This case is interpreted as starvation under an extremely restrictive event-centric mode rather than as an unconditional advantage of the method.

3.2. Computational Complexity and Decision Time

In the actual receiver log, each adaptive decision evaluated 13 candidates: six for temperature, six for humidity, and one binary/sensor candidate for shock_event. Across 180 consecutive decisions, the mean selector runtime on the Linux edge node was 0.229 ms, the median was 0.206 ms, P95 was 0.399 ms, P99 was 0.665 ms, and the maximum was 0.740 ms. With a telemetry cycle of approximately 2 s, even the maximum decision time is small for the current configuration. However, this benchmark covers only M=3 and K=13 and does not demonstrate scalability to tens or hundreds of components; such configurations require separate scalability testing.

4. Discussion

The results show that the selector optimizes utility per unit of resource rather than minimizing the error of each component independently. The most consistent gains are observed under the normal and event_monitoring/limited modes, where the selector reduces resource cost relative to the baselines while maintaining low discrete staleness for T/H. At the same time, for humidity the adaptive policy often selects low/sensor, resulting in higher MAE/RMSE than the high/edge baseline.

Data-driven resource planning has already been demonstrated in smart-city applications, where clustering and forecasting can support the allocation of operational resources [25]. The present study extends this resource-allocation perspective to task-aware digital twin state updates.

Compared with bandwidth-limited and freshness synchronization approaches [12,13,14], the proposed method considers several update dimensions jointly. These include the state component, detail level, processing location, and task-dependent priority. Unlike the AoI-energy and delay-aware formulations discussed in [15,16], the present experimental validation is restricted to directly calibrated network and computational costs. The observed trade-offs therefore support a task-dependent resource-allocation interpretation rather than a claim of universal superiority over freshness-oriented policies.

The comfort_monitoring/critical mode demonstrates a different trade-off: the adaptive policy consumes fewer resources than freshness-only and periodic but has worse H-error and shock F1. The absence of false negatives for shock is due to the emergency override, whereas false positives arise because the last true twin_value is intentionally retained when false updates are omitted.

The event_monitoring/critical mode revealed a structural limitation of the current heuristic. A high task weight for shock_event together with saturating age pressure does not guarantee eventual refresh for T/H, so these components may starve. For general use, an anti-starvation rule, a maximum allowable age, or a minimum guaranteed update frequency should be introduced. The current version of the method does not include a separate anti-starvation mechanism; its development and experimental validation are therefore directions for future research.

As shown in Figure 5, under the critical resource budget the Freshness and Periodic policies limit maximum staleness of temperature and humidity to two cycles, while Adaptive–Comfort limits it to three cycles for temperature and one cycle for humidity. In contrast, under Adaptive–Event both components remain without updates for 179 cycles. This indicates starvation of slow-changing components under an extremely restrictive event-oriented mode and defines the applicability limit of the current heuristic. A logarithmic vertical scale is used in Figure 5 to display both the small staleness values and the value of 179 cycles.

The theoretical model includes d, c, e, and τ, whereas the experiment directly evaluated only the physically calibrated d and c. Energy consumption was not measured in hardware, and RTT was treated as a system-level characteristic of the entire transmission cycle. Therefore, the experimental conclusions primarily concern network cost, computational work, accuracy, state staleness, and selector runtime.

All normal, limited, and critical scenarios were replayed using the same physical reference trace, ensuring identical input conditions across policies. This design separates policy effects from differences between sequential physical phases, although it does not substitute for multi-day or multi-node field validation. The results therefore support the laboratory feasibility of the method, but they do not establish global optimality or industrial scalability.

5. Conclusions

This study addressed the problem of managing digital twin state updates in a resource-constrained edge environment. The proposed method combines, within a single cycle, the selection of the state component, detail level, and processing location. Unlike approaches focused on individual aspects of synchronization, the decision is formed with regard to the current application task and available resources.

The mathematical model was aligned with the practical implementation through separate evaluation of update and no-update options, a staleness indicator, normalized error, component weights, and resource cost. The practical algorithm does not seek an exact solution over the entire planning horizon; instead, it sequentially selects locally best candidates and builds the plan according to their priority. The time complexity of one decision is O(K+M log M).

In the final implementation, T/H have physically defined low/medium/high levels; location=sensor denotes quantization before transmission, location=edge denotes quantization after transmission of the raw value, and send=false physically removes the field from HTTP/JSON. The edge-node decision is applied in the next cycle. For omitted T/H, zero-order-hold is used only for scoring, while the digital twin state is not updated and age increases. An active shock_event is handled by an emergency override.

The final comparison was performed on a single 180-cycle physical reference trace; 179 cycles were used for consistent evaluation of six adaptive scenarios and six baseline scenarios. The planned B/P constraints were not violated in any of the 12 scenarios. Under the normal budget, the proposed method reduced mean d and c by approximately 5.26% and 11.02%, respectively, relative to the periodic/freshness baselines. Under event_monitoring/limited, the savings were approximately 3.97% for d and 10.38% for c at max age=1. Under comfort_monitoring/critical, relative to freshness-only, the savings were approximately 11.73% for d and 19.30% for c, but they were accompanied by higher state error.

Metrics independent of task_utility revealed a trade-off between resource cost and digital-state accuracy: the high/edge baseline provides lower T/H error, whereas the adaptive policy selects coarser detail in some modes to reduce resource cost. For shock, FN=0 in all scenarios due to the emergency override, but in comfort_monitoring/critical F1=0.8678 because the stale true state is temporarily retained.

For the current configuration with 13 candidates, the mean decision time was 0.229 ms, P95 was 0.399 ms, and the maximum was 0.740 ms. This confirms the practical speed of the laboratory implementation.