Learning Node Trustworthiness in Permissioned Blockchain Consensus Using Reinforcement Learning

Trust management has been widely studied in distributed systems and has recently gained renewed attention in blockchain environments due to the decentralized and trustless nature of these networks [6]. Ensuring reliable node behavior, secure participation, and robust consensus remains a fundamental challenge, particularly in the presence of malicious or selfish actors. Existing solutions can be broadly classified into three main categories. The first category includes traditional trust and reputation models, which evaluate node reliability based on historical interactions, feedback aggregation, and reputation scores, and have been widely applied in peer-to-peer and multi-agent systems, such as EigenTrust [13] and PeerTrust [14]. However, these approaches often exhibit limited adaptability and scalability when directly transferred to blockchain networks. The second category comprises blockchain-specific trust management approaches that integrate trust evaluation into the blockchain architecture or consensus process using on-chain data, smart contracts, and immutable transaction records. Nevertheless, many of these methods rely on static or rule-based mechanisms and fail to capture the dynamic and evolving behavior of nodes [15, 16]. The third category focuses on RL-based consensus and validation mechanisms, where intelligent agents learn adaptive strategies for trust evaluation, node selection, and reward or punishment allocation [17, 20]. Despite their potential, existing RL-based solutions often rely on simplified trust representations or lack a comprehensive and systematic trust modeling framework. 

2.1 Traditional trust and reputation models

Early trust and reputation models were primarily developed for peer-to-peer and distributed systems, where the main objective was to assess the reliability of participants based on historical interactions and feedback exchanged among nodes. Seminal approaches such as EigenTrust [13] compute global trust values using eigenvector centrality derived from local satisfaction scores, enabling the identification of trustworthy peers in large-scale decentralized environments. Similarly, models such as PeerTrust [14] and Bayesian-based trust frameworks [21] rely on the aggregation of past behavior, transaction outcomes, and peer feedback to estimate node reliability and mitigate malicious activities. These approaches have proven effective in open peer-to-peer systems by promoting cooperation and isolating untrustworthy participants through reputation-based mechanisms.

However, when applied to blockchain environments, traditional trust and reputation models exhibit notable limitations. First, they typically employ static or slowly evolving trust metrics, which limits their ability to adapt to rapidly changing node behavior and sophisticated adversarial strategies commonly observed in blockchain networks. Second, these models are not inherently consensus-aware, as they do not consider the outcome or strength of consensus rounds, nor do they distinguish between benign disagreements and malicious deviations during block validation and agreement processes. As a result, their direct integration into blockchain-based systems may lead to inaccurate trust assessments and reduced robustness under dynamic and adversarial conditions. 

2.2 Trust management in blockchain systems

With the emergence of blockchain technology, a growing body of research has investigated trust-aware and reputation-driven mechanisms to enhance consensus reliability and system robustness. Several studies have proposed reputation-enhanced consensus mechanisms, where voting power, validator selection, or leader election is dynamically adjusted based on the historical behavior of participating nodes, aiming to mitigate the impact of malicious or selfish actors [22]. In parallel, blockchain-based trust management frameworks have been introduced to record trust evidence, behavioral metrics, and reputation scores in an immutable and auditable manner, leveraging the transparency and tamper-resistance of distributed ledgers to improve accountability and traceability [23]. Despite these advances, recent survey studies indicate that the majority of existing blockchain trust models rely on heuristic weight assignments, predefined thresholds, or externally computed reputation values that are not learned from behaviors data [24, 25].

While such approaches enhance resilience against certain attack vectors, they generally lack adaptivity and struggle to capture complex and evolving behavioral patterns exhibited by nodes over time. Furthermore, proposer accountability and validation responsibility are often either overlooked or treated as binary events, failing to reflect the nuanced influence of proposer behavior on consensus outcomes and overall system trustworthiness.

2.3 Reinforcement learning for consensus validation

RL has been increasingly adopted in blockchain systems as a means to enhance performance, security, and adaptability under dynamic and adversarial conditions [26]. Early RL-based approaches mainly focused on optimizing low-level consensus parameters, such as block generation intervals, transaction throughput, block propagation delay, or mining strategies, by modeling blockchain operation as a sequential decision-making process [27, 28]. With the advent of deep RL, more advanced solutions have been proposed to address complex challenges, including anomaly detection, selfish mining mitigation, and intelligent oracle selection, by learning behavioral patterns directly from on-chain and network-level data [29, 30]. More recently, research has shifted toward adaptive and trust-aware consensus mechanisms that leverage RL and multi-agent RL, particularly in permissioned and IoT-enabled blockchain environments, where nodes exhibit heterogeneous capabilities and dynamic trustworthiness [18, 31].

These studies demonstrate that RL is effective in capturing evolving node behavior and adapting consensus decisions accordingly. However, in most existing works, trust is either evaluated implicitly, embedded as an internal control variable, or approximated through reward shaping rather than modeled as an explicit, interpretable metric. As a result, critical aspects such as consensus agreement strength, graded correctness of validation decisions, and proposer responsibility are often overlooked or simplified, limiting the transparency and explainability of trust evolution. In contrast, only a limited number of studies attempt to integrate RL with a formal and comprehensive trust model that explicitly quantifies these factors, highlighting a clear research gap that motivates the proposed approach.

2.4 Comparison with existing approaches

To systematically position existing trust and consensus solutions, Table 1 summarizes their key characteristics with respect to adaptivity, learning capability, consensus awareness, trust granularity, proposer accountability, and explicit trust representation. These dimensions are particularly relevant for blockchain systems operating in dynamic and adversarial environments, where node behavior, consensus outcomes, and validation responsibilities continuously evolve.

Table 1. Comparison of trust and consensus approaches

Traditional reputation systems, such as EigenTrust, compute global trust values from historical interactions and provide explicit and interpretable reputation scores; nevertheless, they neither adapt to dynamic consensus processes nor account for validation responsibility within blockchain environments [13]. Reputation-based distributed ledger consensus frameworks incorporate trust or reputation into validator selection, thereby introducing a degree of consensus awareness; however, they typically rely on static or slowly evolving trust metrics, thereby constraining their responsiveness to behavioral changes [31]. More tightly coupled solutions, such as GT-BFT mechanisms, embed trust evaluation directly into the consensus process by dynamically assessing node behavior to influence block proposal and validation. While this achieves stronger integration between trust and consensus, such approaches still lack learning-based adaptivity [32].

Similarly, trust models designed to enhance blockchain consensus security propose formal trust metrics to identify and exclude unreliable participants, yet they do not incorporate advanced learning mechanisms capable of capturing complex or evolving behavior patterns [33]. Blockchain-specific trust frameworks, including VeriBlock, leverage the immutability and transparency of distributed ledgers to store and audit trust evidence, supporting explicit trust computation; however, trust is generally treated as a static or externally derived quantity rather than as a learned variable [23]. In contrast, RL–based consensus optimization approaches introduce adaptivity by learning optimal consensus parameters or miner strategies through interaction with the environment, but they often focus on system-level performance objectives and do not explicitly model trust, consensus confidence, or proposer accountability in an interpretable manner [27, 28].

More recent adaptive RL-based trust approaches, particularly in IoT and multi-agent blockchain settings, extend RL to dynamically assess node behavior; however, trust is frequently treated implicitly or embedded within reward functions rather than represented as an explicit, graded trust metric [18]. Overall, the comparison reveals a clear trade-off between interpretability and adaptivity: traditional and blockchain-based trust frameworks offer explicit trust scores and auditability but lack learning capabilities, whereas RL-based approaches provide adaptivity and behavioral awareness while often omitting formal trust representation and accountability mechanisms. This gap highlights the need for comprehensive trust-aware frameworks that integrate adaptive learning with explicit, interpretable trust modeling and consensus-aware responsibility attribution.

Overall, existing trust and consensus solutions exhibit a clear gap between adaptive learning capabilities and explicit, consensus-aware trust modeling, motivating the need for approaches that jointly address trust interpretability, dynamic behavior, and accountability. In the next sections, we introduce the proposed RL–based trust framework, describing its trust model, learning components, and consensus-aware design.

This section presents the proposed RL-based trust evaluation framework for permissioned blockchain systems. The method leverages a DDQN to model node behavior and dynamically evaluates trust based on consensus participation, decision accuracy, and proposer responsibility.

4.1 Motivation for Double Deep Q-Networks

In the considered blockchain environment, nodes operate under dynamic and partially observable conditions, where behavioral patterns may change over time due to workload, network latency, or adversarial actions. Classical rule-based trust mechanisms fail to adapt to such non-stationary dynamics.

Deep Reinforcement Learning (DRL) enables an agent to learn optimal decision policies through interaction with the environment. However, standard DQN are known to suffer from Q-value overestimation, particularly in noisy environments such as decentralized blockchain systems.

To address this limitation, the proposed framework adopts a DDQN architecture, which decouples action selection from action evaluation. This design improves training stability and yields more reliable Q-value estimates, making it well suited for trust assessment in permissioned blockchain networks.

A natural question concerns why RL is preferred over supervised learning for this task. Three fundamental reasons justify this choice. First, node behavior in permissioned blockchain environments is non-stationary: behavioral patterns evolve over time due to workload fluctuations, network conditions, and adversarial actions, making it infeasible to define a fixed labeled training set that remains valid across all consensus rounds. Second, no ground-truth trust labels are available at deployment time; the only observable feedback is the final consensus decision $D^r$, which the agent receives as a reward signal rather than a supervised target. Third, trust is not a property of a single interaction but emerges from an accumulated trajectory of consensus participations — a sequential decision process that is inherently better captured by RL than by single-pass classification or regression.

4.2 Architecture of the trust-aware Double Deep Q-Networks framework

Figure 1 illustrates the architecture of the proposed trust-aware framework integrating a DDQN with a permissioned blockchain environment. The architecture is composed of three main components: the blockchain environment, the DDQN agent, and the trust evaluation and rating module.

The blockchain environment models the consensus process executed by a set of authorized validator nodes. In each consensus round, nodes generate local validation decisions, and a final agreement is reached using the PBFT protocol. The environment provides state observations, reward signals, and consensus outcomes (i.e., whether the consensus round succeeds or fails), which are used by the DDQN agent during training. When the consensus decision is valid $\left(D^r=1\right)$, a new block is appended to the blockchain.

The DDQN agent is responsible for learning an optimal policy to predict node decision behavior from observed blockchain states. To improve training stability and sample efficiency, the agent employs an experience replay memory that stores transitions of the form $\left(s_r, a_i^r, r, s_{r+1}\right)$ collected through interaction with the blockchain environment. Mini-batches are randomly sampled from this replay memory during training, which breaks temporal correlations between consecutive samples and reduces variance in gradient updates.

The agent has two neural networks: an online network and a target network. The online network is used for action selection and policy learning, estimating the action-value function $Q(s, a; \theta)$. At each step, the selected action is determined by an $\epsilon$-greedy policy based on the online network outputs. The target network, parameterized by $\theta^{-}$, is a delayed copy of the online network and is updated periodically to provide stable Q-value targets during training. Following the DDQN formulation, the target value $y_t$ used to update the online network is computed by decoupling action selection from action evaluation. Specifically, the online network selects the best action for the next state. The online network parameters are then updated by minimizing the temporal-difference loss between the predicted Q-value and the target value. This separation between action selection and evaluation mitigates Q-value overestimation and significantly improves the stability and convergence of the learning process.

1.png

Figure 1. Architecture of the proposed trust-aware Double Deep Q-Networks (DDQN) framework

Importantly, trust evaluation is driven by the online DDQN network, which directly determines node trust ratings through its interaction with the blockchain environment. Trust scores are computed from consensus outcomes resulting from online network decisions, including graded correctness, faulty behavior, proposer responsibility, and accumulated penalty feedback across consensus rounds.

This design ensures that trust scores faithfully capture observed node behavior rather than abstract model inference, thereby enhancing interpretability, and robustness. The resulting trust ratings provide a reliable measure of node credibility and can be readily integrated into higher-level consensus optimization and governance mechanisms.

4.3 Q-network architecture

The Q-network is implemented as a fully connected feedforward neural network. It consists of an input layer corresponding to the state dimension, followed by two hidden layers with $64$ neurons each and Rectified Linear Unit (ReLU) activation functions. The output layer contains two linear neurons, representing the estimated Q-values for each action. Formally, the Q-function approximation is defined as:

$Q(s, a; \theta) \approx f_\theta(s)$,

where, $\theta$ denotes the trainable network parameters.

To stabilize training, a target network $Q^{\prime}\left(s, a ; \theta^{-}\right)$ is maintained as a delayed copy of the online network. The target network parameters $\theta^{-}$ are periodically updated by copying the weights from the online network.

An experience replay buffer $\mathcal{D}$ stores transitions of the form:

$\left(s_r, a_i^r, r, s_{r+1}, \mathbb{I}_{\text {done }}\right)$,

which are uniformly sampled during training. This mechanism breaks temporal correlations between consecutive experiences and improves sample efficiency.

The DDQN target is computed as:

$y_r=r+\gamma Q^{\prime}\left(s_{r+1}, \underset{a^{\prime}}{\operatorname{argmax}} Q\left(s_{r+1}, a^{\prime}; \theta\right), \theta^{-}\right)$,

where, $\gamma$ is the discount factor.

The loss function is defined using the Huber loss to reduce sensitivity to outliers:

$\mathcal{L}(\theta)=\mathbb{E}_{\left(s, a, r, s^{\prime}\right) \sim \mathcal{D}}\left[\ell\left(y_r-Q(s, a; \theta)\right)\right]$.

For the exploration strategy, an $\epsilon$-greedy exploration policy is employed to balance exploration and exploitation. At each step, the agent selects a random action with probability $\epsilon$, and the greedy action otherwise.

The exploration rate decays exponentially across episodes:

$\epsilon_{k+1}=\max \left(\epsilon_{\min}, \epsilon_k \cdot \lambda\right)$,

where, $\lambda \in[0,1]$ controls the decay speed.

4.4 Training procedure

The training process iteratively interacts with the blockchain environment over multiple episodes. During each episode, the agent observes node states, predicts actions, receives rewards based on consensus correctness, and updates the Q-network using sampled experiences. Algorithm 1 summarizes the complete training procedure.

This section presents an experimental evaluation of the proposed DDQN-based trust assessment framework. The evaluation analyzes the learning dynamics of the agent, the impact of exploration–exploitation trade-offs, and the resulting trust score evolution. All observations are supported by plots generated during training and testing.

Experiments are conducted on a permissioned blockchain network composed of N = 20 validator nodes operating over sequential consensus rounds (R = 600), producing one record per node per round, yielding (20 × 600 = 12000) interaction traces in total. The validators are simulated using the JADE platform [35], where each node runs within its own isolated container to enable accurate measurement of resource consumption, including CPU and memory usage. A Practical PBFT consensus protocol is employed, in which one node is selected as proposer in each round and the remaining nodes submit local decisions regarding block validity. During this process, the DDQN agent interacts with the JADE simulation environment in an online manner. At each consensus round, the environment generates state observations and consensus outcomes in real time, which are immediately fed to the agent as experience transitions. This design reflects a realistic deployment scenario where the agent learns continuously from live consensus activity rather than from a pre-collected static dataset.

To evaluate the framework’s ability to identify adversarial behavior, three nodes $n_{16}, n_{17}$, and $n_{18}$ are designated as byzantine during the simulation. These nodes systematically cast votes opposite to the correct block decision in most consensus round, representing worst-case adversarial behavior within PBFT’s fault tolerance bound of $f \leq\left\lfloor\frac{N-1}{3}\right\rfloor=6$, where N = 20.

The RL agent interacts with the environment at the granularity of a node-round pair. Each interaction step corresponds to one row in the dataset.

6.1 Dataset and training configuration

The dataset consists of approximately ~12,000 records, each representing a node participation in a consensus round. Each record includes operational metrics (latency, CPU usage, memory usage), behavioral indicators (local decision, proposer role), and historical trust-related attributes. Training is performed using:

• Number of episodes: E = 50
• Training steps per episode: equal to the number of dataset rows
• Replay buffer size: 20,000 transitions
• Batch size: 64
• Discount factor: $\gamma=0.99$
• Learning rate: 10^-3
• Target network update interval: 1,000 steps

All continuous state features are normalized prior to training to ensure numerical stability.

6.2 Exploration strategy and epsilon decay

Figure 2 illustrates the evolution of the exploration rate $\epsilon$ across training episodes. The exploration rate is initialized at $\epsilon_0=1.0$ and decays exponentially with a factor of 0.95 per episode.

2.png

Figure 2. Evolution of the exploration rate (ϵ) over training episodes

Over 50 training episodes, ϵ decreases from 1.0 to 0.0809, ensuring extensive exploration during early episodes and a gradual shift toward exploitation as training progresses. Specifically, ϵ falls below 0.5 after 14 episodes and below 0.2 after 33 episodes, indicating a controlled reduction of random actions.

This decay schedule enables stable policy learning by preventing premature convergence while allowing the agent to rely increasingly on learned Q-values in later training stages.

6.3 Training loss analysis

Figure 3 presents the training loss measured at each learning step over approximately 1.2 × 10⁵ updates. During early training, the loss exhibits high variance, with peak values reaching approximately 0.55, reflecting unstable Q-value estimates and limited replay buffer diversity. As training progresses, the loss rapidly decreases and remains consistently below 0.1 for the majority of steps, with bounded oscillations induced by stochastic minibatch sampling.

3.png

Figure 3. Training loss values measured at each learning step

4.png

Figure 4. Average training loss per episode over 50 episodes

Figure 4 reports the average training loss aggregated per episode over 50 episodes. The loss decreases sharply from 0.1305 in the first episode to 0.0336 by episode 5, and falls below 0.01 after episode 9. Convergence is observed from approximately episode 15 onward, where the average loss stabilizes below 0.003 and remains within the range [4.4 × 10^-4, 1.35 × 10^-3] for the remainder of training.

The absence of any increasing loss trend or divergence in later episodes indicates stable convergence of the DDQN and suggests that the learned value function does not suffer from overfitting. This behavior confirms the effectiveness of the target network, experience replay, and DDQN update mechanism in maintaining training stability. 

6.4 Reward analysis

Figure 5 presents the cumulative reward obtained per episode over 50 training episodes. The reward curve shows a monotonic upward trend after the initial exploration phase, indicating progressive improvement in the agent’s ability to predict node behavior consistent with the final consensus decision. 

The cumulative reward increases from -178 in the first episode to 718 by episode 2, reflecting rapid policy adaptation once sufficient experiences are collected. From episode 5 onward, the reward exceeds 2000 and continues to grow steadily, reaching 6124 at episode 15 and 9316 by episode 30. In the final phase of training, the reward stabilizes with smaller incremental gains, culminating at 11032 in episode 50.

The absence of reward collapse or oscillatory behavior in later episodes indicates stable policy convergence. This sustained reward growth, combined with the stabilized loss values reported earlier, confirms that the DDQN successfully learns a consistent decision policy without overfitting or performance degradation. 

5.png

Figure 5. Cumulative reward obtained per episode over 50 training episodes

6.5 Q-value stability

Figure 6 illustrates the evolution of the average estimated Q-values at each training step. During the early learning phase, Q-values increase rapidly as the agent explores the state–action space and refines its value estimates. This transient growth reflects the correction of initially uninformative value predictions.

Figure 7 presents the average Q-values aggregated per episode over 50 episodes. The average Q-value increases from 3.66 in episode 1 to 10.24 in episode 2 and exceeds 18.0 by episode 5. After episode 10, the Q-values converge toward a stable range centered around 20.0, with minor bounded oscillations.

6.png

Figure 6. Average estimated Q-values at each training step

7.png

Figure 7. Average Q-values per episode over 50 training episodes

From episodes 10 to 50, the average Q-values remain tightly bounded within [19.94,20.05], indicating stable value estimation and the absence of divergence or overestimation. This stabilization confirms the effectiveness of the DDQN formulation, where decoupling action selection from value evaluation mitigates the overestimation bias commonly observed in standard DQN.

The convergence of Q-values, combined with the stabilized loss and increasing reward trends reported earlier, demonstrates that the learned policy reaches a consistent and reliable value function approximation suitable for trust evaluation in permissioned blockchain environments.

6.6 Trust score evolution and node rating analysis

This analysis examines the evolution of node trust scores at the end of training and explains how the proposed framework distinguishes reliable, risky, and potentially malicious nodes based on observed behavior.

Table 2 reports the final trust scores of the 20 evaluated nodes. The trust values are computed using the weighted trust formulation described previously, with the following parameters used throughout all experiments:

$\alpha=1.0, \beta=1.2, \delta=0.8, \gamma=0.5$

The parameter $\alpha=1$ serves as the baseline weight for correct validation behavior. A slightly larger value $\beta=1.2$ is used to penalize faulty decisions more strongly due to their higher impact on consensus reliability. The proposer contribution is weighted with $\delta=0.8$ since block proposal occurs less frequently than validation actions. Finally, $\gamma=0.5$ moderates the effect of accumulated penalties to avoid excessive trust degradation from occasional faults.

Table 2. Final trust scores of evaluated nodes

The obtained trust scores exhibit a clear stratification of node behavior. Nodes such as $n_9, n_2, n_7, n_{10}$, and $n_{19}$ achieve trust values above 76, indicating consistently correct participation, low fault rates, and positive proposer contributions. These nodes can be classified as highly reliable validators and are suitable candidates for critical consensus roles.

A second group of nodes, including $n_0, n_1, n_3, n_4, n_5$, and $n_{13}$, obtain trust scores in the range 70–75. These nodes demonstrate generally correct behavior but exhibit occasional faults or penalty accumulation. They are considered moderately reliable and may require monitoring under stricter consensus conditions.

At the lower end of the trust spectrum, the three byzantine nodes $n_{16}$, $n_{17}$, and $n_{18}$, deliberately injected with adversarial behavior during the simulation, receive the lowest trust scores of 62.23, 60.95, and 57.59 respectively, resulting from high graded fault rates, repeated penalties, and limited positive proposer impact. The framework detects and penalizes their systematic adversarial voting through the fault contribution $F_i$ and penalty rate components of final trust score function, without requiring any prior knowledge of node identity or attack strategy. Node $n_{11}$ (with score 62.44) exhibits intermittent faulty behavior consistent with a selfish or transiently faulty node, demonstrating the framework's ability to differentiate between deliberate and non-deliberate misbehavior. Such nodes should be excluded or down-weighted in the consensus process.

Overall, the results demonstrate that the proposed DDQN–based framework effectively captures long-term node behavior and provides an adaptive, interpretable trust assessment for robust consensus management in permissioned blockchain systems.

6.7 Baseline comparison

To justify the complexity of the proposed trust formulation, we compare it against a simple reputation baseline that computes node trust as the plain fraction of correct validation decisions, without confidence weighting, proposer accountability, or penalty rate:

SimpleReputation$_i=\frac{\text { correct decisions}_i}{\text { total participations}_i} \times 100$

Table 3 reports the trust scores produced by both methods on the same dataset. The simple reputation baseline assigns nearly identical scores to all nodes, with a total range of only 2.83 points and a standard deviation of 0.80. Critically, it assigns an average score of 88.05 to the three byzantine nodes $n_{16}$, $n_{17}$, and $n_{18}$, compared to 89.30 for the top honest nodes, resulting in a gap of only 1.25 points that renders byzantine detection effectively impossible.

In contrast, the proposed DDQN trust framework produces a range of 22.26 points and a standard deviation of 6.33, representing a 7.9× improvement in score spread. The average trust score of byzantine nodes drops to 60.26, compared to 78.42 for top honest nodes, yielding a separation gap of 18.16 points, which represents a 14.5× improvement over the baseline. This result confirms that the multi-component trust formulation, which integrates fault contribution, proposer accountability, and penalty rate alongside correct-rate weighting, is essential for meaningful node differentiation and adversarial detection in permissioned blockchain environments.

Table 3. Baseline comparison: Simple reputation vs. proposed Double Deep Q-Network (DDQN) trust

6.8 Ablation study on trust coefficients

To assess the sensitivity of the trust formulation to coefficient selection, four configurations of $(\alpha, \beta, \delta, \gamma)$ are evaluated on the same dataset. The value of α is always fixed at 1.0 to serve as a normalization reference, allowing β, δ, and γ to be interpreted as relative weights with respect to the baseline contribution of correct validation behavior. Beyond the default setting (1.0, 1.2, 0.8, 0.5), three variants are considered: a higher fault penalty $(\beta=1.5)$ to reflect stricter consensus requirements, a reduced proposer weight $(\delta=0.4)$ to limit the influence of block proposal frequency, and a higher penalty rate ($\gamma=1.0$) to enforce stronger punishment for accumulated faults.

Table 4 reports the resulting trust scores across all configurations. Despite variations in coefficient values, the relative ranking of nodes remains highly consistent: $n_9$ and $n_2$ consistently occupy the top two positions across all settings, while the three byzantine nodes $n_{16}$, $n_{17}$, and $n_{18}$ remain at the bottom in all configurations. The maximum rank displacement observed across all nodes is 4 positions, with a mean displacement of 1.35, confirming that the trust ordering is stable and not an artifact of a specific parameter choice. These results validate that the proposed trust formulation captures genuine behavioral differences rather than coefficient-dependent artifacts, and that the default configuration represents a balanced and robust parameterization.

Table 4. Ablation study: Trust scores under different coefficient configurations

6.9 Discussion

The stable convergence observed from episode 15 onward, with a final cumulative reward of 11,032, confirms that RL-based trust learning is feasible without pre-labeled data. This is a fundamental advantage over static reputation models such as EigenTrust [13] and PeerTrust [14], which cannot update their trust estimates in response to behavioral shifts observed across consensus rounds.

The 22.26-point spread across 20 nodes produce three operationally distinct tiers that directly inform governance decisions: nodes scoring above 76 are suitable for critical proposer roles, those in the range 70–75 require monitoring, and those below 63 should be excluded or down-weighted. This degree of differentiation is not achievable by threshold-based approaches such as RCF [32] or GT-BFT [34], which classify nodes into binary or coarse-grained trust categories without learning-based refinement.

The clear separation between the top and bottom tiers is driven in part by the proposer responsibility component (Penalty rate), which distinguishes nodes that lead successful consensus rounds from those that repeatedly propose invalid blocks. This dimension is absent in VeriBlock [23], which records trust evidence on-chain but treats proposer behavior as a binary event, and in RL-based optimization approaches [27, 28], which focus on system-level performance without modeling proposer accountability explicitly. 

Compared to adaptive RL trust models in IoT settings [18], the proposed framework produces fully explicit and interpretable trust scores derived from observable consensus outcomes rather than embedding trust implicitly within reward functions, making the scores directly usable for validator governance without requiring access to the agent's internal state.

In contrast, the proposed framework simultaneously satisfies key trust and learning requirements. It is fully adaptive and RL-based, explicitly integrates consensus outcomes into trust evaluation, supports graded trust computation, and directly incorporates proposer accountability. Trust scores are computed exclusively from observable blockchain events, ensuring interpretability while remaining responsive to dynamic and adversarial behavior. This combination enables a more comprehensive and reliable assessment of node credibility compared to existing approaches, as confirmed by the experimental results.