A Time-Entangled Self-Reconstructing Framework for Fault Tolerance in Distributed Real-Time Systems

Abstract

Fault tolerance in distributed real-time systems has, up till now, relied on static redundancy, replication, or predictive mechanisms, which introduce latency, resource overhead, and inadaptability under dynamic failure conditions. This paper presents Chrono Weave (CW) as a revolutionary new idea that describes how a system is working as a flow of a time-ordered field of states, so that even if the system is broken, it can recover without explicit redundancy or replication. CW does not replicate computation but rather encodes system evolution into temporally entangled microstates; therefore, recovery is made possible through deterministic temporal interpolation. The Temporal Consistency Field (TCF), a new concept, is presented to measure system integrity over time, enabling fault localization and instant reconstruction. The new system does not require standby replicas, and recovery is achieved just by way of using temporal coherence that is inherent. From a theoretical viewpoint, it is shown that CW can reduce recovery latency asymptotically towards zero as long as the drift is bounded. From the perspective of distributed control, simulation experiments have still managed to show great recovery speed and system reliability improvements over the traditional ones. This paper opens fault-tolerant computing to a new mode of operation where instead of being based on redundancies, time-structured, self-healing systems are used.

1. Introduction

Nowadays, distributed real-time systems are integral to our major infrastructures: industrial automation, autonomous transportation, smart grids, and medical monitoring platforms. In these systems, one cannot only wish for reliability; it is a firm demand [1]. Even the shortest faults may spread rapidly and cause the whole system to become unstable or even fail catastrophically. Ensuring that a system is fault-tolerant within very limited timing constraints is still one of the major problems in system design. Distributed real-time systems have become indispensable in a variety of critical applications that require high levels of reliability, timing accuracy, and fault tolerance. Examples of such systems include automated industrial plants in smart factories, networks of autonomous vehicles, smart electrical grids, distributed healthcare monitoring systems, cloud-edge computing infrastructures, and large-scale Internet of Things (IoT) environments. These systems consist of several interconnected nodes that continuously exchange information and collectively execute time-sensitive tasks within strict operational constraints [2].

System failures in one location of a distributed system are capable of being quickly spread to other units through functional interactions imposed by the temporal dependency and communication coupling. For instance, delayed or corrupted sensor data can mislead decision-making in autonomous transport systems, and a lack of synchronization is the cause of instability in power distribution in smart grids. On the other hand, in industrial automation environments, communication faults between distributed controllers can interrupt coordinated production processes and cause cascading operational disruptions [3].

This is the reason why fault tolerance in distributed systems goes beyond simply recovering the individual node states to also maintaining the temporal coherence and the stability of the entire system evolution. These real-world challenges greatly encourage the invention of adaptive and temporally robust fault recovery mechanisms such as the CW framework proposed by the authors. Most of the time, fault tolerance techniques are created by taking advantage of the idea of redundancy. Methods based on replication keep parallel copies of components, so that a broken one can be replaced immediately. Checkpointing methods save the system state at intervals, making it possible to go back to a stable state before the failure [4]. Lately, adaptive and learning-based methods have also been studied to forecast faults before they happen. Even though these methods have been successful in quite a few cases, essentially, they have some common drawbacks. Redundancy is associated with very high computational and memory requirements, checkpointing leads to a recovery time, there may be a loss of synchronization with the recorded state during the interval, and predictive methods rely on uncertain models that may fail when confronted with new conditions that have not been seen before [5].

Most traditional methods consider system states as discrete, standalone entities to be preserved or restored at any cost, so that each system state is a snapshot independently frozen and reversible in time [6]. Nevertheless, they may be ignoring the very nature of real-time systems, which are changing continuously over time. States of systems are not isolated moments but rather closely related through the dynamics of time [7]. Hence, if a state is lost or corrupted, it does not mean that all information has been lost if the temporal structure of the system remains intact. In fact, observing these facts, we came up with a completely new fault tolerance method, based not on redundancy, but on temporal coherence instead [8]. We do not rely on keeping copies or duplicating system states but rather consider system execution as a temporally structured unfolding, with each state being implicitly coded in the temporal neighborhood. Therefore, the concept of damage or failure refers to the loss of a physically stored element and not to the inability to recompose the system state from its temporal context.

Following such a change in paradigm, we developed CW, an innovative framework that integrates fault tolerance with the time dimension of distributed systems, making the latter more reliable through being resilient in the temporal dimension. It is predicated on the idea of a temporal consistency field that formalizes the local temporal coherence of the system states and makes the anomalies recognizable as temporal deviations from the norm. The fault does not cause the system to depend on replicas or past checkpoints. Instead, by employing temporally consistent preceding information, it recreates the corrupted state and, in this manner, the system evolution is restored. As illustrated in Figure 1, instead of relying on redundant replicas, the proposed framework reconstructs missing node states through weighted temporal fusion of neighboring node dynamics.

This method offers many benefits. For starters, it totally removes the dependence on explicit redundancy, which results in a drastic decrease in resource usage. Another point is that it allows you to recover almost immediately since the rebuilding is done based on the temporal information available locally and does not involve rollback or synchronization at all. Finally, it naturally guards against a variety of fault types, such as transient disturbances, burst errors, and even total loss of state by taking advantage of temporal and distributed coherence.

The remainder of this paper is organized as follows. Section 2 reviews existing fault-tolerance approaches for distributed real-time systems, including redundancy-based, checkpoint-based, adaptive, and learning-driven methods. Section 3 presents the proposed CW framework together with the TCF and the TTRE. Section 4 describes the simulation environment, experimental setup, and comparative performance evaluation under different fault conditions and communication delays. Finally, Section 5 concludes the paper and discusses future research directions and potential real-world applications of the proposed framework.

2. Related Works

Fault tolerance in distributed real-time systems has been a focus of intense research, with a vast array of solutions available to make these systems resilient even in the worst situations [9]. Basically, the existing methods are categorized by three main paradigms: redundancy-based mechanisms, rollback-based recovery, and temporal or adaptive filtering strategies [10]. Although each of these approaches has been proven effective in certain cases, they also rely on a few assumptions that hinder their scalability and efficiency in highly changing environments. Redundancy-based methods are considered to be the oldest and most popular fault tolerance techniques [11]. Through these methods, system components can be duplicated either spatially, by means of parallel replicas, or temporally, by running the same program multiple times [12]. Primary-backup and active replication are two commonly used methods that, in case of failure, quickly provide another functioning system without loss of data or service disruption by always having a backup copy of the system state. Even though such methods guarantee high reliability, they may result in a considerable increase in computation and memory usage, especially when the system becomes larger in scale [13]. Moreover, the need to keep different copies consistent with each other leads to extra communication delays and complexities in synchronization, which might prove to be a challenge for real-time systems with stringent timing requirements [14].

Checkpointing and rollback mechanisms present another option by saving system states at intervals and restoring them when there is a failure [15]. Coordinated and uncoordinated checkpointing methods have been the subject of extensive research to find a good compromise between keeping the system consistent and running it efficiently [16]. These methods allow for less continuous data replication, yet have the downside of the recovery time being longer as the system is returning to the saved state and executing the computations again [17]. In a fault-prone and unpredictable environment, the checkpoint-based solution can cause subsequent rollbacks, resulting in a significant decrease in system performance.

Also, as checkpointing is discrete, it cannot keep up with system changes, so the stored state may be at odds with the real state. Recently, some scholars have gone further to examine the adaptivity and prediction of fault onset to a degree where, through the testing of other system aspects, the deterioration or failure has been recorded, and then the system is dynamically smoothed and filtered to lessen the effect of the fault [18]. In fact, these systems infer the most recent changes to estimate current states, typically using statistical or learning-based models [19]. Such techniques, although they enhance the system reactivity and decrease the workload, are still dependent on prediction accuracy; their performance deteriorates when faced with new or extreme fault patterns [20]. On top of that, a variety of proposals fail to reconsider temporal information as a fundamental property of the system, instead considering it an ancillary feature. One of the more recent reasons that neural, network-based, and learning-oriented methodologies have become more and more popular in fault management of distributed systems is their ability to capture complex temporal and nonlinear behaviors of the system. Deep learning techniques have been unleashed for fault diagnosis, detecting anomalies, adaptive system monitoring, and intelligent management of recovery processes in complex and changing distributed environments. Recurrent neural network and temporal sequence models are frequently the tools that are leveraged to dissect system states that are changing with time and able to detect pre-failure abnormalities in the temporal patterns. In the same way, graph-based neural architectures have been examined as ways of representing the dependencies between the nodes and the communication structure of distributed networks.

Learning-based methods offer a couple of perks, such as the ability to not only model the behavior of a system adaptively but also become sensitized to very subtle fault states that may, in fact, be difficult to pinpoint by rule-based methods. In Industrial Internet of Things (IIoT), smart grid infrastructure, and autonomous distributed platforms, neural models have shown quite a bit of promise in maintenance prediction and fault forecasting under constantly changing operating conditions. On the downside, such approaches are generally dependent on having a very large amount of training data, a fairly good understanding of the representative fault patterns, and one or more continuous retraining cycles if one is to keep the model robust under evolving environments.

What is more, neural prediction-centric methodologies might encounter the problem of performance reliability when they are pathologically exposed to unknown fault distributions, communication irregularities, or sudden and swift temporal dynamics. Quite often, these kinds of methodologies tend to almost exclusively focus on estimating the likelihood of failure occurrence or giving a forecast of failure, disregarding the fact that after a system has been corrupted, it is also very important to be able to reconstruct the evolution of the system in a temporally coherent manner.

CW, the novel framework that is presented, does not hinge on the root of the fault predication that is acquired through learning or the processes that need data-driven training. It gets to the bottom of system states from time-coherent observations directly by means of deterministic consistency-driven temporal reconstruction. Treating system evolution as one continuous temporal manifold rather than a series of discrete states, the framework at hand unchains adaptive fault recovery from the need for explicit prediction models and replica synchronization. Gaps in these paradigms include the treatment of system states as isolated entities that must be saved, copied, or inferred [21]. This view forcibly separates the process of fault recovery from the system’s natural development and makes external mechanisms necessary for restoring consistency [22]. For that reason, recovery is frequently linked with more resource consumption, delays, or lack of certainty [23].

However, the main idea of the method that we suggest here is very different. Instead of using redundancy or prediction as the basis, the idea is to consider the system operation as a temporally regular process where each state is indirectly represented within the nearby temporal context. As a result, recovery can be achieved by rebuilding the temporal structure instead of finding the stored states. With fault tolerance being a natural part of the system’s temporal behavior, the current framework does not need explicit backup or rollback operations. This fundamental change from state preservation to temporal coherence is what sets the proposed method apart from the existing ones and, at the same time, is a source of a new line of thought for a fault-tolerant system design. Instead of viewing faults as problems that need external fixing, the system is capable of repair through its own temporal continuity, which results in the system being able to operate efficiently and stably even in tough conditions.

3. Methodology

We present CW, a completely different approach to fault-tolerant distributed systems, which discards the traditional method of redundancy-based recovery and introduces time-structured state reconstruction. Rather than creating multiple copies of the same computation for different replicas, CW represents the system evolution as a continuous time field, where each node state is not temporally separate but rather is part of a common temporal manifold throughout the entire network (Figure 2).

Consider a distributed real-time system composed of $N$ interacting nodes. At any time $t$, the global system state is defined as:

$$S(t)=\{s_1(t),s_2(t),\dots ,s_N(t)\},{ s}_i(t)\in {\mathbb{R}}^d$$

(1)

While in traditional approaches states are considered separate and independent snapshots, we interpret system evolution as a continuous manifold in time, where each state is naturally connected to its temporal neighbors. A fault is not recognized as simple failure or success, but rather as a break in temporal coherence, mathematically defined as:

$$\exists t: \left|\right|S\left(t\right)-\mathcal{F}\left(S\right(t-\delta ), S(t+\delta \left)\right)\left|\right|>ϵ$$

(2)

where $\mathcal{F}$(⋅) represents a temporal consistency operator. The temporal consistency operator $\mathcal{F}$(⋅) is treated as a deterministic nonlinear operator that checks the coherence between the present system state and its temporally nearby states. In contrast to the usual linear filtering methods, $\mathcal{F}$(⋅) not only is responsive to local temporal changes but also maintains the natural continuity of the system evolution with the help of bounded perturbations. The operator is capable of measuring temporal deviation energy through the combination of changes in states, local temporal gradients, and the imposition of consistency-preserving coherence constraints. Therefore, sudden changes in state due to faults result in inconsistent responses that are much greater than those of temporal fluctuations that occur naturally or models of temporal continuity. We propose the Temporal Consistency Field (TCF), a continuous representation that traces the system evolution over time:

$$\mathcal{T}(t)={\int }_{t-∆}^{t+∆}\omega \left(\tau \right) S\left(\tau \right)d\tau$$

(3)

where $\mathcal{T}\left(t\right)$ aggregates temporal information within a bounded window $∆$, and $\omega \left(\tau \right)$ is a temporal coherence kernel. The temporal kernel ω(τ) is a key component of the proposed Temporal Consistency Field, since it defines the weight of past states for estimating temporal coherence and for determining the accuracy of reconstruction. In this framework, ω(τ) is made to be a kernel that is bounded, positive, and monotonically decaying, so it first gives more importance to temporally closer observations and then less and less to very distant states. Such a formulation is a direct reflection of the assumption that nearby temporal states maintain stronger dynamical correlations, thus being more trustworthy sources of information for reconstruction:

$$\int \omega \left(\tau \right)d\tau =1$$

(4)

This scheme allows the system to locally keep a stable time-based representation, even when only a part of the state is corrupted. Each node is equipped with a time series of states:

$${\mathcal{H}}_i\left(t\right)=\left\{s_i\right(t-k\delta ),\dots ,s_i(t\left)\right\}$$

(5)

Instead of storing raw checkpoints, CW encodes these trajectories into time-linked microstates:

$${\varphi }_i(t)={\displaystyle {\sum }_{k=1}^K}{{\rm Y}}_k·s_i(t-k\delta )$$

(6)

where ${{\rm Y}}_k$ is a temporal decay coefficient dynamically adapted based on system stability. Encoding this temporal information in a low-dimensional yet highly informative representation will eliminate the necessity for explicit replication. The time-linked microstate representation encodes the recent temporal evolution of each node into a compact temporally coherent structure. Rather than treating historical observations equally, the proposed framework assigns adaptive temporal decay coefficients that regulate the contribution of previous states according to their temporal reliability and consistency with the current system evolution. The temporal decay coefficients are dynamically adapted rather than fixed globally. Their values are determined according to local temporal stability, inconsistency energy $D\left(t\right)$, and recent trajectory variation. States exhibiting strong temporal coherence with the current system evolution receive larger weights, whereas temporally inconsistent or corrupted states are progressively suppressed. This adaptive weighting mechanism enables the reconstruction process to remain robust under transient disturbances and rapidly changing fault conditions. For systems with relatively smooth and slowly evolving dynamics, slower temporal decay preserves longer historical context and improves reconstruction stability. In contrast, highly dynamic distributed environments benefit from faster decay behavior, which prioritizes recent observations and reduces the influence of outdated or corrupted information. Consequently, the temporal encoding mechanism can adapt to different application scenarios while preserving computational efficiency and temporal coherence. CW samples the environment to find faults by quantifying temporal inconsistency energy:

$$D(t)=||S(t)-\widehat{S}(t){\left|\right|}_2$$

(7)

where $\widehat{S}(t)=\mathsf{\Psi }(\mathcal{T}(t))$ is the reconstructed expectation derived from the temporal field. A fault is triggered when $D\left(t\right)>{\in }_t$, with ϵ_t being a dynamic threshold:

$${\in }_t=\lambda ·Var\left(\mathcal{T}\right(t\left)\right)$$

(8)

This makes detection adaptive, avoiding false positives under natural system fluctuations.

Temporal Reconstruction Engine

The Temporal Reconstruction Engine (TRE) makes up the main component of the CW framework, which is capable of restoring the system after faults even when no replication, checkpointing, or predictive models are used. Rather than failure being viewed as the permanent loss of a system state, TRE is based on the idea that system change is inseparably continuous through time and that any system state can be derived from its respective time series. When a fault occurs, the observed system state S(t) becomes inconsistent with its expected temporal evolution. This inconsistency can be expressed as a deviation from the temporally coherent estimate $\widehat{S}(t)$, where the deviation magnitude $D(t)=||S(t)-\widehat{S}(t)||$ reflects the degree of disruption. Rather than discarding the corrupted state or replacing it with a stored copy, TRE interprets this deviation as a signal that temporal coherence has been locally violated. To restore consistency, the system relies on a short-term temporal memory composed of past observations:

$$\left\{S\right(t-\delta ),S(t-2\delta ),\dots ,S(t-K\delta \left)\right\}.$$

These states are not treated equally; instead, each one contributes to reconstruction based on how well it aligns with the underlying temporal structure. The reconstructed state $S_{rec}\left(t\right)$ is therefore obtained as a weighted combination of historical states:

$$S_{rec}(t)={\displaystyle \frac{{\displaystyle {\sum }_{k=1}^K}{\alpha }_{k}S(t-k\delta )}{{\displaystyle {\sum }_{k=1}^K}{\alpha }_k}}$$

(9)

where the weights ${\alpha }_k$ are dynamically determined by temporal consistency. In particular, each weight is defined as:

$${\alpha }_k=exp(-\beta |\left|S\right(t-k\delta )-\mathcal{T}(t\left)\right|\left|\right)$$

(10)

with $\mathcal{T}\left(t\right)$ representing the Temporal Consistency Field. This is achieved by giving more weight to states that are very close to the system time progress and naturally lowering the weight of states that are inconsistent or corrupted. Therefore, TRE carries out a filtering step in a hidden way, without finding the erroneous samples on purpose. The main difference of this method is that reconstruction is not a simple interpolation. It keeps up the natural sequence of the system dynamics by making the reconstructed state stay in line with the system time path. This could be realized by the fact that the reconstructed state is required to be coherent with the local evolution pattern, which, in fact, can be estimated by temporal differences. In practice, this means that the change between $S_{rec}\left(t\right)$ and its preceding state remains consistent with the observed trajectory, preventing artificial discontinuities.

In distributed systems, reconstruction is further enhanced by incorporating information from neighboring nodes. Let $s_i\left(t\right)$ denote the state of node iii. The recovered state can then be extended to include cross-node contributions:

$$S_{rec,i}(t)={\displaystyle \frac{\sum _j\sum _k{\alpha }_{jk}{s}_j(t-k\delta )}{\sum _j\sum _k{\alpha }_{jk}}}$$

(11)

where the weights ${\alpha }_{jk}$ encode both temporal and inter-node consistency. This allows the system to reconstruct missing or corrupted states even when local information is insufficient, effectively leveraging distributed coherence without introducing explicit redundancy.

To ensure stability, the reconstructed state is not immediately enforced. Instead, it is gradually blended with the previous system state:

$$S^{\prime }(t)=(1-\eta )S_{rec}(t)+\eta S(t-1)$$

(12)

where $\eta ϵ [0,1]$ controls the rate of reintegration. This prevents abrupt transitions and ensures that recovery does not introduce secondary instability into the system.

It is also worth mentioning that TRE can be adjusted. The number of previous states considered for the reconstruction is not set; rather, it changes according to the degree of deviation D(t) detected. A short time window is enough for minor deviations, which means the system can correct itself quickly. If there is a big disturbance, the temporal window is extended to add more data, thereby enhancing the system’s reliability but leading to slightly more time consumption. From the computational viewpoint, TRE behaves in a linear fashion with respect to the length of the temporal window, as it only needs to perform a weighted combination of recent states. As a result, it is much more efficient compared to redundancy-based methods, which suffer from storage and synchronization burden. CW introduces a time-aligned synchronization constraint:

$$\forall i,j : \left|\right|s_i\left(t\right)-s_j(t-{∆}_{ij})\left|\right|<\xi$$

(13)

where ${∆}_{ij}$ is communication delay. Instead of enforcing strict synchronization, CW allows for bounded temporal drift, preserving real-time performance while maintaining consistency.

In Figure 3, the robustness of the CW framework was further tested through a set of experiments with varying inter-node communication delays ${∆}_{ij}$. This was carried out to find out whether the CW framework can still work effectively under conditions of distributed systems as real as those you can find outside the laboratory. Communication latency figures prominently in distributed real-time environment synchronization, and if coherence between times is not maintained properly, degradation of reconstruction quality is the likely result.

Communication delays in the simulation environment were represented as temporal offsets constrained within certain time bounds between neighboring nodes. The three delay settings that were considered included low-delay conditions (${∆}_{ij}$ ∈ [1, 3] ms), medium-delay conditions ${∆}_{ij}$∈ [5, 10] ms), and high-delay conditions (${∆}_{ij}$ ∈ [15, 25] ms). For each of these, transient faults, burst disturbances, and complete state loss scenarios were examined with the same reconstruction protocol.

4. Experiment Setup

4.1. Simulation Environment

To assess how well our CW framework performs, we built a controlled simulation that can be used as a testbed for distributed real-time systems’ fault behavior. The system is made up of several connected nodes that carry out time-dependent operations; at each node, a continuous state vector is preserved, and nodes communicate only with their neighbors within a certain maximum latency. The simulation is performed in Python 3.11.9 with a special event-driven engine, and the system dynamics are represented as smooth temporal processes with stochastic perturbations that are controlled. The simulation environment was implemented in Python using a custom event-driven simulation engine specifically developed for the proposed CW framework. The implementation additionally utilized several standard scientific computing and visualization libraries to support temporal modeling, numerical computation, performance evaluation, and result visualization. Numerical operations and temporal state processing were implemented using NumPy 1.26.4, while stochastic perturbation generation and statistical analysis were supported through SciPy 1.13.1. Experimental data handling and metric aggregation were performed using Pandas 2.2.2. Visualization of temporal trajectories, reconstruction behavior, and comparative performance plots was conducted using Matplotlib 3.8.4. The event-driven coordination logic, TCF, adaptive thresholding mechanism, and TRE were implemented as custom Python modules specifically designed for distributed temporal reconstruction experiments. Communication delays, fault injection scenarios, and temporal synchronization behavior were simulated through asynchronous event scheduling within the custom engine. All experiments were executed under identical simulation conditions to ensure fair comparison across baseline methods and the proposed framework. The modular implementation also enables scalability analysis and flexible adaptation to different distributed system configurations and fault scenarios. A node’s state changes by applying a continuous update function with noise; hence, the system is capable of reproducing the operational variability typical of real life. Communication delays between nodes are represented as bounded temporal offsets to mirror the network conditions that are most often experienced in distributed settings.

Faults are deliberately inserted to test how well recovery systems perform. The research experiments with three main fault types: transient noise corruption, where the state is affected by random disturbances; burst faults, where the state changes drastically over a short period; and complete state loss, where the node’s state is either null or random values. These fault scenarios are randomly timed and distributed among different nodes to simulate the unbiased evaluation of recovery methods. Each technique’s effectiveness is assessed using three major criteria. Recovery latency captures how long it takes for the system to achieve a stable state after encountering a fault. Reconstruction error represents the extent of the difference between the recovered state and the actual state trajectory. On the other hand, system stability is about the extent to which the recovery causes oscillations or other disturbances, and it is assessed through variance in the recovery-phase trajectory. These measures, when taken together, reflect not only how accurately the recovery mechanism works but also its practical effectiveness

Table 1. Main algorithm parameters used in the proposed CW framework.

Parameter	Description	Value	Selection Criteria
λ	Temporal reconstruction blending coefficient	0.82	Selected to balance smooth reintegration and rapid recovery
β	Adaptive threshold sensitivity parameter	0.15	Empirically optimized to reduce false-positive fault triggering
η	Temporal decay adaptation factor	0.93	Chosen to preserve short-term temporal coherence while suppressing outdated states
Δ	Maximum allowable temporal synchronization drift	25 ms	Defined according to distributed communication delay constraints
K	Temporal observation window size	12 states	Determined through sensitivity analysis for stable reconstruction accuracy

.

The stability score is used to quantify the smoothness and temporal consistency of the recovery process after fault occurrence. Unlike reconstruction error, which measures the difference between reconstructed and ground-truth states, the stability score evaluates how steadily the distributed system returns to coherent operation without introducing oscillatory or unstable behavior during recovery. Higher stability score values indicate smoother recovery dynamics, reduced oscillatory behavior, and stronger preservation of temporal coherence during reconstruction. Lower values correspond to unstable temporal evolution, abrupt state transitions, or amplified recovery fluctuations after fault occurrence.

$$SS=1-{\displaystyle \frac{1}{T_r}}{\sum }_{t=t_f}^{t_f+T_r}{\displaystyle \frac{{‖S_r\left(t\right)-S_r\left(t-1\right)‖}^2}{max\left(ϵ,{\sigma }_{ref}\right)}}$$

(14)

where $SS$ denotes the stability score, $S_r\left(t\right)$ represents the reconstructed system state at time $t$, $t_f$ is the fault occurrence time, and $T_r$ denotes the recovery interval over which temporal stability is evaluated. The parameter ${\sigma }_{ref}$ represents a normalization coefficient derived from nominal system dynamics, while ϵ is a small constant introduced for numerical stability. This metric is particularly important in distributed real-time systems because rapid recovery alone is insufficient if the reconstruction process introduces secondary instability or propagating temporal inconsistencies across neighboring nodes. Therefore, the stability score complements latency and reconstruction accuracy metrics by evaluating the dynamic robustness of the recovery process itself.

4.2. Experimental Results

For a thorough assessment, we present the outcomes of several fault scenarios along with various metrics. The comparison encompasses replication-based recovery, checkpointing, temporal smoothing, and the newly introduced CW framework. Experimental results reveal that CW is not only faster but also more stable in recovery than other baseline methods. For transient fault cases, CW can bring system consistency back very shortly since the temporal structure is mainly preserved. On the other hand, checkpoint methods must roll back, so they suffer from long delays, while replication introduces switching overhead.

During burst fault occurrences, CW is able to retain a smaller reconstruction error primarily because its consistency-driven weighting effectively downgrades corrupted states and, at the same time, maintains genuine temporal information in

Table 2. Performance under transient faults.

Method	Recovery Latency (ms)	Reconstruction Error ↓	Stability Score ↑	Overhead
Replication	42.7	0.031	0.91	High
Checkpointing	78.4	0.045	0.84	Medium
Temporal smoothing	18.6	0.092	0.62	Low
CW	9.8	0.027	0.95	Low

. On the other hand, the smoothing-based method totally flops in this scenario, as it is incapable of differentiating valid from corrupted states, which is why it results in impaired accuracy.

In Figure 4, each temporal step corresponds to one event-driven simulation update cycle with a fixed interval of (∆t = 1) ms. During each update cycle, distributed nodes exchange local state information, evaluate temporal consistency, and update reconstruction variables within the TCF. Communication delays and fault injections are applied asynchronously within these update intervals to simulate realistic distributed system behavior. The temporal axis therefore represents the progressive evolution of the distributed system during fault occurrence and recovery. The failure point (t_f) shown in the figure corresponds to the simulation instant at which temporal inconsistency exceeds the adaptive threshold defined in Equation (8), triggering the TRE. Subsequent temporal steps illustrate how the proposed framework restores system coherence and stabilizes the reconstructed trajectory over time.

CW is able to fully reconstruct the lost state from temporal and cross-node information, even in the scenario of complete state loss. Methods based on replication still manage to obtain a good result here, but their drawback is the high and even enormous resource consumption in Figure 5 and

Table 3. Performance under burst faults.

Method	Recovery Latency (ms)	Reconstruction Error ↓	Stability Score ↑	Failure Recovery Rate (%)
Replication	55.2	0.048	0.88	96.1
Checkpointing	112.3	0.071	0.79	91.4
Temporal smoothing	25.7	0.134	0.58	74.6
CW	14.5	0.039	0.93	97.8

. Methods relying on checkpoints have the problem of slow recovery, and they show discontinuity due to the knowledge of the old, stored states in

Table 4. Performance under complete state loss.

Method	Recovery Latency (ms)	Reconstruction Error ↓	Stability Score ↑	Resource Cost
Replication	7.2	0.021	0.94	Very high
Checkpointing	135.6	0.063	0.81	Medium
Temporal smoothing	Failed	High	Low	Low
CW	16.9	0.028	0.92	Low

and

Table 5. Robustness under increasing fault frequency.

Fault Frequency	Method	Recovery Latency (ms)	Error	Stability
Low	Replication	40.3	0.029	0.92
	CW	9.5	0.026	0.96
Medium	Replication	52.1	0.041	0.89
	CW	12.8	0.031	0.94
High	Replication	71.6	0.067	0.83
	CW	19.3	0.044	0.91

.

To further evaluate the influence of the temporal observation window, we conducted a sensitivity analysis with respect to K, which determines the number of previous states used by the Temporal Reconstruction Engine. The results are summarized in

Table 6. Sensitivity analysis of temporal window size K.

K	Recovery Latency (ms) ↓	Reconstruction Error ↓	Stability Score ↑
4	10.2	0.052	0.87
8	12.1	0.036	0.91
12	13.6	0.029	0.93
16	15.4	0.030	0.92
24	19.8	0.034	0.90

.

The results indicate that increasing K improves reconstruction accuracy and stability up to a moderate window size because more temporally coherent observations are available for state recovery. However, excessively large windows introduce older states that may be less representative of the current system dynamics, leading to increased latency and slightly reduced stability. Therefore, K = 12 was selected as the default temporal window size because it provides the best trade-off among recovery latency, reconstruction error, and system stability.

4.3. Comparison with State-of-the-Art Methods

Comparing our novel CW framework to some of the most well-known SOTA methods in fault-tolerant distributed systems is one of the steps to further confirm the effectiveness of our framework. The chosen approaches represent the main existing paradigms in the literature, namely, reliability through redundancy, recovery through rollback, and control that is both time-aware and adaptive based on the changing situation. More exactly, the comparative study features a primary-backup replication model (PB-Replication), a coordinated checkpointing approach (C-Checkpoint), and an adaptive temporal filtering method (ATF) aimed at reducing transient inconsistencies through smoothing. These methods have been the first choice in real-time distributed systems thanks to their trustworthiness and ease of implementation in practice. The assessment was run with the same simulation settings for all methods, which is a guarantee of the comparability of the findings. Moreover, the utilized fault injection patterns, system dynamics, and communication constraints were the same for each method. The measurements were performed several times at random in order to be statistically representative.

To achieve a fair and unbiased comparison, all methods were evaluated under the same simulation and distributed system settings. Essentially, baseline methods and the CW framework were subjected to identical network topologies, communication constraints, temporal update intervals, stochastic perturbation, and fault injection scenarios. Each method was exposed to the same transient faults, burst disturbances, and complete state loss at identical times and to the same severity levels. Also, communication delays, temporal synchronization conditions, and reconstruction evaluation windows were kept constant throughout all experiments.

Baseline methods, when applicable, were set up with the same temporal observation horizons and similar computational settings to ensure no bias in parameter selection. The metrics of recovery latency, reconstruction error, stability score, and resource overhead were used in the evaluation for all methods. In addition, each experiment was conducted multiple times with different random initialization conditions, and the results reported represent the average performance. This process mitigates stochastic bias and ensures a statistically fair comparison between the proposed framework and the competing fault-tolerance methods.

The findings show that CW manages to strike a very good balance among several important factors of recovery, such as speed, accuracy, and the use of resources in

Table 7. Comparison with SOTA methods.

Method	Type	Recovery Latency (ms) ↓	Reconstruction Error ↓	Stability ↑	Resource Overhead ↓
PB-Replication	Redundancy	8.4	0.022	0.95	Very high
C-Checkpoint	Rollback	121.7	0.058	0.82	Medium
ATF (adaptive temporal filter)	Temporal	21.3	0.087	0.68	Low
CW(ours)	Temporal reconstruction	13.6	0.029	0.93	Low

. PB-Replication has the shortest recovery time; the small issue in performance is compensated by the fact that system states are continuously being duplicated, which imposes a big computational and memory burden. Such a solution becomes more and more of a nightmare as the system scale increases. Checkpoint-based recovery, e.g., C-Checkpoint, is less responsive due to rollback operations and the latency between checkpoints, resulting in its reconstruction error being greater, which is also reflected in its lower stability, especially under conditions of frequent faults and faults that are unpredictable. The hybrid temporal filtering method is quite good at giving better latency and making better use of the available resources, but when there are big disturbances, it is not able to maintain the level of accuracy of reconstruction in Figure 6. Because there is no way for it to tell the difference between reasonable and corrupted states, it loses stability and errors increase.

On the other hand, CW rarely makes mistakes in reconstruction and still has a recovery latency that is close to the best. CW is very good at keeping the system stable and not causing oscillations or new disturbances that come as a result of recovery. This is due to the fact that the reconstruction method of the system highlights the information that is consistent over time and, at the same time, reduces the effects of anomalies. Additionally, CW does not need explicit redundancy or rollback, and this makes its overhead of resources way lower than methods based on replication. This makes it very appropriate for situations where the environment is large-scale or resources are limited.

5. Conclusions

This paper proposed CW, a brand-new framework of fault tolerance for distributed real-time systems that is radically different from the traditional redundancy- and rollback-based approaches. Rather than maintaining system reliability by replication, checkpointing, or prediction, the new approach sees system execution as a temporally coherent process, where each state is inherently situated within its temporal context. This way of thinking makes it possible to recover by reconstructing the temporal structure rather than by obtaining stored states. The Temporal Reconstruction Engine, which is able to rescue system states after they have been corrupted by faults, for example, through consistency-driven aggregation of temporally aligned observations, is one of the key components of CW.

By focusing on temporally coherent information and, at the same time, ignoring anomalies, the framework, without adding any extra resource overhead, recovers accurately and stably. The combination of temporal consistency modeling with adaptive reconstruction enables the system to cope efficiently with various types of faults, such as transient disturbances, burst faults, and complete state loss.

Experimentation results indicate that our approach is able to keep the recovery latency low and yield high-quality reconstruction while preserving system stability quite well, as opposed to the representative state-of-the-art methods. More specifically, CW is able to retain low recovery time and availability with high stability without resorting to the use of redundant resources, which makes it very suitable for both real-time and resource-constrained environments. Apart from the results of the experiments, the main contribution of this paper is a framework that shifts fault tolerance from the preservation of discrete system states to the maintenance of temporal coherence. The introduction of this new angle in the research leads to the design of resilient distributed systems where recovery is no longer a separate activity but is one in which the system is naturally evolving.

Despite the promising experimental results, the current study still has several limitations that should be acknowledged. The proposed CW framework has been validated only within a controlled simulation environment specifically designed to emulate distributed real-time system behavior under various fault conditions. Although the simulation incorporates communication delays, stochastic perturbations, and multiple fault scenarios, real-world distributed systems may exhibit additional complexities, including hardware heterogeneity, unpredictable network instability, asynchronous processing behavior, and non-ideal communication constraints that are difficult to fully reproduce in simulation.

Further research will be directed towards enlarging the proposed framework so that it can be applied to more complex and diverse environments, such as large-scale cyber-physical systems and edge computing architectures. At the same time, analyzing theoretical limits on temporal coherence as well as combining the framework with deployment in the field will help establish a more solid basis for its use and reliability.