Hierarchical Continuous Monitoring and Resource Reallocation Under Resistance to Change: A Decision-Making Framework Balancing Skill Constraints and Managerial Capacity

Abstract

Organizational change is a complex process often accompanied by intense human reactions and increased uncertainty. Resistance to change (RtC) can cause critical performance declines during the organizational change period, which can delay implementation. The evolution of information systems and digital infrastructures provides immediate access to operational data and analytical tools, making it possible to continuously monitor performance and timely adjust decisions during change. Although recent approaches attempt to minimize these impacts through continuous monitoring and resource reallocation, they typically view human resource allocation as a single-level problem. In hierarchical structures where work and decision-making are distributed across levels, RtC can increase backlogs, place an excessive amount of work on managers, and result in operational issues or the failure of the change. From an algorithmic perspective, the proposed method formulates a hierarchical dynamic optimization problem with two coupled assignment layers, in which the operational output of Level 1 dynamically determines the workload processed at Level 2. Both assignment problems are solved at each time step using the Hungarian algorithm, while RtC is modelled as a time-dependent stochastic process aligned with a reference change curve, allowing employee and managerial performance to be updated dynamically over the planning horizon. In contrast to static Classical Change Management Model (CCMM), large-scale experimental results demonstrate that the new approach increases total processed workload by approximately 20%, while at the peak of resistance, the improvement reaches 56.8%. At the same time, it substantially reduces backlog accumulation, maintaining very low backlog levels (18 versus 16,424 units) within the tested setting. Finally, by applying a 50% reallocation threshold, the organization maintains 98.5% of maximum performance while avoiding 45% of the reallocations. Overall, the proposed method provides a dynamic optimization framework that combines hierarchical organizational modeling with stochastic performance updates across organizational levels.

1. Introduction

Organizations increasingly rely on planned change initiatives to respond to competitive pressure, technological disruption, and evolving operational requirements. Despite the existence of numerous change management models [1,2], it is observed that a particularly high percentage of initiatives are not completed or are abandoned before completion [3,4,5]. According to the literature, this failure is attributed to human factors. Resistance to Change (RtC) is recognized as a major factor [6,7]. RtC often leads to emotional distress, uncertainty, and reduced cooperation during the change process [6,7,8].

To address RtC, the evolution of organizational change management has incorporated a variety of theoretical and practical approaches [2,9]. In this context, data collection through quantitative and qualitative methods, such as questionnaires and interviews, is constituted a fundamental tool in the decision-making phase. Through this diagnostic process, the necessary operational steps are defined and the overall change strategy is formed. In addition, to further reduce resistance, organizational readiness is significantly enhanced through targeted staff training and the timely identification of capable change agents who take on the critical role of leadership [1,10,11,12].

A recent research addressed the importance of real-time decision support during changing periods by introducing CoMoRe a Continuous Monitoring and Reallocation method. This approach based on updated performance data allows for effective adjustments during periods of change [13]. This method was subsequently extended in the Performance Improvement Through Training and Employee Reallocation (PITTER) method, which is developed as a mathematical decision-making approach based on Evolutionary Dynamic Multi-Objective Optimization. PITTER incorporates training and worker reallocation in the presence of RtC. It is designed to improve performance while accounting for behavioural variability during implementation [14].

In many real organizational environments, and particularly in manufacturing or service units, tasks are performed by small teams, where a manager supervises a limited number of employees. This structure can be represented as a hierarchical “star topology,” with a central managerial node connected to employee nodes [15].

Research indicates that change is systematically implemented within hierarchical organizational structures [15,16]. In these hierarchical structures, any failure of managerial nodes to effectively coordinate tasks results in a backlog of work. This threatens the stability of the system and prevents the successful implementation of change [17].

Although the literature suggests a multitude of change management models, high failure rates indicate that Resistance to Change (RtC) is not always addressed in a timely manner during the implementation phase. Classic diagnostic approaches (questionnaires, interviews) and preparatory interventions (training, selection of change agents) are useful, but often require significant time and organizational effort, because of which RtC may escalate before effective countermeasures are activated.

While CoMoRe [13] and PITTER [14] provide operational mechanisms for dynamic personnel reallocation, a significant limitation is identified: both approaches primarily treat the workforce as a set of workers to be assigned to tasks. The hierarchical structure of the team, through which decisions are produced and enacted (e.g., a manager directing and coordinating a small team), is not explicitly represented. Furthermore, a formal and transparent structure of worker quality, which could systematically guide allocation decisions beyond short-term performance fluctuations, remains to be introduced. This gap is particularly important in hierarchically organized schemes (e.g., “star topology”), where RtC is diffused the hierarchically structure. Dysfunctions in managerial nodes can cause work accumulation and undermine the stability and successful implementation of change.

The main innovation of this paper lies in the development of a dynamic, hierarchical decision-making framework for resource reallocation in multi-level organizational structures. From a computational perspective, this contribution is realized through the formulation of a multi-level assignment problem under stochastic performance constraints, where personnel allocation is periodically adjusted based on updated performance and Resistance to Change (RtC) indicators. In contrast to traditional static approaches, the proposed framework introduces an iterative algorithmic optimization process in which the operational output of Level 1 (employees) dynamically redefines the demand and effective capacity requirements of Level 2 (managers) at each time step. This coupling of two interdependent assignment problems, solved through repeated applications of the Hungarian algorithm, enables the model to capture workload propagation across the two hierarchical levels, support operational stability, and limit backlog accumulation during periods of high performance variability.

Following this introduction, the article is divided into four main parts. Section 2 presents the literature review including current change-management models, the Human Resource Allocation Problem (HRAP) with recognition of agent qualifications, and the hierarchical diffusion of resistance and its impact on human resources. The proposed method and its application are presented in Section 3. Next, Section 4 analyses the experimental results, leading to the final conclusions and limitations described in Section 5.

2. Literature Review

2.1. Change Management Models

Organizational change management is a process that aims to address employee reactions during the implementation of change plans. The classic theoretical model of Kurt Lewin and its latest variations use the three phase model “Unfreeze”, “Change” and “Freeze” states [18,19,20] presented in Figure 1.

The success of change initiative depends largely on training plans, preparation of the organization leadership’s ability to communicate the need for change. These actions help to reduce the uncertainty that fuels RtC [1,9,11,21].

However, even with sufficient preparation, a consistent pattern in the change process is the “change curve,” which depicts a temporary but critical drop in performance, the so-called “death valley” [22], before gradually entering a recovery phase. While some individuals accept and even support the change, others exhibit intense resistance due to emotional distress and uncertainty, which is often associated with the widely reported high failure rate of change initiatives [23,24,25,26]. Moreover, newer approaches [7] emphasize that the depth and duration of this “death valley” are directly influenced by the hierarchical structure and mainly by the quality of leadership, which is called upon to manage the employees emotional and the operational costs of the change.

The dynamic recovery phase is characterized by the gradual adaptation of personnel to the new data and by the transformation of the initial decline into an upward trend. As shown by the ADKAR model (Awareness, Desire, Knowledge, Ability, and Reinforcement) [27] and by the application of the CoMoRe [13] and PITTER [14] methods, recovery is not automatic. It requires continuous monitoring, targeted interventions, and resource reallocation to support critical functions. In hierarchical organizational structures, it becomes even more important to consider how decisions are made and how resource constraints are distributed across hierarchical levels [15,16]. In this stage, the emphasis is on acquiring new skills and strengthening the ability of employees, so that the driving forces of change can overcome the remaining resistance and stabilize the new state presented in Figure 1. The specific studies use as a basis the three-phase process of organizational change.

The stabilization stage (Freeze—New State) concerns the consolidation of the change and the achievement of a new, superior equilibrium. According to Hasan et al. [17], “New State” does not simply constitute the end of the process, but the institutionalization of the new practices, so that they become consolidated at the level of behaviours, processes and hierarchy.

2.2. Human Resource Allocation, Scheduling, and Qualification-Constrained Assignment

The classical Assignment Problem concerns the optimal assignment of a set of m workers to a set of n tasks, with the aim of minimizing the total cost. The solution is based on the constraint that each task is assigned to a single worker and each worker undertakes exactly one task. Accordingly, in the Human Resource Allocation Problem (HRAP) with qualification recognition, the objective is to maximize the total utility, incorporating the critical constraint that the assignment depends on the specialized skills of the workers, as not all resources have the required quality for each task [28]. The mathematical model follows:

$$\mathrm{Maximize}\sum _{i=1}^m\sum _{j=1}^n{c}_{ij}{x}_{ij}$$

(1)

Subject to constraints:

$$\sum _{i=1}^m{q}_{ij}{x}_{ij}\le 1\forall j=1,\dots ,n$$

(2)

$$\sum _{j=1}^n{q}_{ij}{x}_{ij}\le 1\forall i=1,\dots ,m$$

(3)

$$x_{ij}=0\mathrm{or}1$$

(4)

where $x_{ij}=1$ if human resource i is assigned to task j, 0 if not; $q_{ij}$ = 1 if human resource i is qualified to perform task j, 0 if not; and $c_{ij}$ equals the utility of assigning human resource i to task j, (with $c_{ij}$ = 0 if $q_{ij}$ = 0).

Beyond the classical Human Resource Allocation Problem, the proposed framework is also related to operations research and scheduling studies on flexible job-shop, resource-constrained, and batch/parallel-machine scheduling [29,30,31]. At the same time, its emphasis on hierarchical adaptation under dynamic conditions is also consistent with broader recent work on adaptive hierarchical decision frameworks [32,33]. However, while these streams of research mainly focus on production-oriented or control-oriented objectives, the present work addresses hierarchical resource reallocation under RtC-driven performance degradation and dynamic workload propagation across organizational levels.

2.3. Hierarchical Diffusion of Resistance and Its Impact on Human Resources

First, the organizational hierarchy must be defined as the context within which these dynamics develop. According to the literature, the hierarchical structure is traditionally organized into three interrelated levels: top management, which acts as the initiator and designer of change; middle management, which acts as the critical link, and operational staff, who are the ultimate recipients [34].

The literature describes hierarchical organizational structures as layers (levels) of positions connected by formal reporting lines between managers and employees. These lines influence the flow of information, tasks, and attitudes, as well as the diffusion of RtC across levels [35].

In its traditional structure, hierarchy is the framework within which day-to-day operations are organized. It defines who reports to whom and a chain of command to monitor and control the assignment and execution of tasks at all levels [36,37].

The current literature highlights the hierarchy as a field of two-way diffusion of resistance, where the dynamics of change are influenced by both downward and upward flows. On the one hand, the trickle-down effect shows that managers’ attitudes towards change can be transmitted downward to subordinates and influence the way they perceive the feasibility and safety of the change [16].

On the other hand, resistance can move upwards when the collective reaction at the base limits the fidelity of implementation and undermines the strategy of the top [38], while middle management may, due to self-protective motives, produce forms of counter effort or filter information upwards [39]. At the same time, prolonged uncertainty and the burden of daily operations during the change can increase the phenomenon of human resource churning, i.e., voluntary departures that lead to the need for replacement and significant costs, such as loss of knowledge and skills, cost of new hires and training, as well as burden on colleagues who remain [40]. Excessive role overload increases RtC. When middle managers determine that they do not have the skills, time or resources to meet the demands, they are much more likely to resist organizational change [40].

3. Methodology

3.1. Problem Description

The main problem is to manage employee RtC within a hierarchical organizational structure. While organizational transformations aim to improve performance, systemic resistance often undermines implementation and leads to poor results. This is typically represented by the change curve [22], which is characterized by a steep decline in productivity, the “death valley,” before any recovery is observed.

In this study, as shown in Figure 2 the term employees refers to operational staff (Employee Level), while managers refer to the managerial level responsible for node-level processing assignments. Accordingly, the proposed framework is modelled as a two-layer hierarchical system: Level 1 (Employee Level), where employees are assigned to tasks, and Level 2 (Managerial Level), where managers are assigned to processing nodes in order to regulate effective capacity and support demand fulfilment.

For example, Figure 2 depicts the process for completing a task within an organization. The organization is divided into separate vertical modules, where each colour corresponds to a different department (e.g., blue = Module A, green = Module B). Within each module, the flow is from bottom-up and passes through four levels (submodules): Tasks → Employees → Managers → Next Level. In Module A, the process begins with tasks (Task A1–A4). Each task is assigned to an employee (Emp A1–A4) with a 1-to-1 mapping. Then, the output produced by the employees is consolidated by Manager A, who acts as the main point of coordination and control. Finally, Manager A forwards the results of the tasks to the next level (Next A1–A4). The same applies to all modules. It is important that there are no horizontal connections between different modules (e.g., Manager A is not connected to Manager B), so each department operates independently.

When middle managers start to perform poorly, it can lead to an increase in their workload and, eventually, a breakdown of the entire organizational structure. Because the system cannot dynamically adapt to these variations in actual capacity, tasks that cannot be completed immediately are carried over to the next time step. This leads to a catastrophic accumulation of backlog. Consequently, the real problem is not simply a temporary drop in productivity, but rather a complete operational collapse. The organizational unit is overloaded with an unmanageable volume of delayed tasks, unable to utilize its remaining, but poorly distributed, capacity. It is argued that through the implementation of this continuous monitoring and regular readjustment, both employees and managers will optimize their performance.

The problem presented previously is based on the following constraints and assumptions:

Constraints for each hierarchical level:

(a)

Each task is assigned to exactly one employee at the first level of the hierarchy.

(b)

Each employee is assigned to exactly one task.

(c)

After the tasks are completed at the first hierarchical level are completed, the results are passed on upward. Each manager is assigned to process a set of tasks.

(d)

The positions of employee and manager are strictly separate. The corresponding operational and supervisory tasks cannot be assigned to each other.

With the following assumptions:

(a)

The size of the organization remains constant throughout the change period, with no human resources changes (turnover or hiring).

(b)

The tasks produced in a sub-module remain committed to the corresponding processing node (manager position) and no redistribution of tasks between nodes is allowed.

(c)

Each employee possesses a set of required qualifications for a specific subset of tasks.

(d)

Each employee has a baseline, known performance for each task.

(e)

All managers hold the necessary expertise required for manager nodes at the second hierarchical level.

(f)

Each manager’s performance and capacity are known for their respective positions.

(g)

Resistance to change presented by each employee or manager, during change period, follows the Change Curve model [22].

More specifically, suppose there is an organization that wants to implement a change within a hierarchical structure. At the first level of the hierarchy, n tasks (jobs) are carried out by n employees, where each task is assigned to exactly one employee and each employee is assigned to exactly one task. Not all employees are eligible for all tasks: each employee possesses a specific set of qualifications and can be assigned only to a subset of tasks for which the required qualifications are satisfied. After completion, the results of the tasks are forwarded hierarchically upwards, where the manager nodes function as processing nodes. Each manager assigned to a node is responsible for completing a specific set of tasks. The positions of employee and manager are distinct and switching between them is not allowed.

The organization aims to remain as productive as possible and to utilize its human resources in a way that maximizes the highest overall performance. This can be achieved by optimizing the allocation of personnel during the change period. Although the organization’s goal remains unchanged, it also seeks to minimize the time required to successful change implementation.

The formulation of this problem builds upon the mathematical model of the CoMoRe [13] and extends it to incorporate hierarchical processing and quality constraints. The objective function includes the performance $P_{ij}$ of each employee i on each task j, adjusted dynamically to reflect resistance to change, and it is maximized to obtain the best overall performance. Furthermore, tasks produced within a given sub-module remain committed to their corresponding processing node (managerial position), and redistribution of tasks between nodes is not allowed. Nevertheless, managers may be reassigned across managerial positions according to business efficiency criteria. The mathematical model is formulated as follows:

• Sets and Indices

  (a)

  N: Number of employees and tasks.

  (b)

  i: Index of employees ($i=1,\dots ,N$).

  (c)

  j: Index of employees tasks ($j=1,\dots ,N$).

  (d)

  M: Number of managers, indexed by $m=1,\dots ,M$.

  (e)

  K: Number of manager positions (nodes), indexed by $k=1,\dots ,K$.

  (f)

  T: Total time steps, indexed by $t=0,\dots ,T$.

• Parameters

  (a)

  $P_{ij}\left(t\right)$: Performance of employee i when assigned to task j at time step t.

  (b)

  $P_{mk}\left(t\right)$: Performance of manager m when assigned to node k at time step t.

  (c)

  $q_{ij}\in \{0,1\}$: Binary skill mask matrix; equals 1 if employee i is qualified for task j, and 0 otherwise.

  (d)

  $C_m$: Base processing capacity of manager m.

  (e)

  $R_{ij}\left(t\right)$: Resistance to change of employee i when assigned to task j at time step t.

  (f)

  $R_{mk}\left(t\right)$: Resistance to change of manager m when assigned to node k at time step t.

• Decision Variables

  (a)

  $x_{ij}\left(t\right)\in \{0,1\}$: equals 1 if employee i is assigned to task j at time step t, and 0 otherwise.

  (b)

  $y_{mk}\left(t\right)\in \{0,1\}$: equals 1 if manager m is assigned to node k at time step t, and 0 otherwise.

Part A:

Level 1 Mathematical Model

The objective is to maximize the overall employee performance of the assignments at any given time step.

$$\underset{x\left(t\right)}{max}\sum _{i=1}^N\sum _{j=1}^N{P}_{ij}\left(t\right)x_{ij}\left(t\right)$$

(5)

Subject to constraints

$$\sum _{i=1}^N{x}_{ij}\left(t\right)=1\forall j=1,\dots ,N$$

(6)

$$\sum _{j=1}^N{x}_{ij}\left(t\right)=1\forall i=1,\dots ,N$$

(7)

$$x_{ij}\left(t\right)\le q_{ij}\forall i=1,\dots ,N,;\forall j=1,\dots ,N$$

(8)

$$x_{i,j}\left(t\right)\in \{0,1\}\forall i=1,\dots ,N,;\forall j=1,\dots ,N$$

(9)

where $q_{ij}\in \{0,1\}$ denotes the qualification indicator, defined as

$$q_{ij}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}\mathrm{employee}i\mathrm{is}\mathrm{qualified}\mathrm{for}\mathrm{position}j,\hfill \\ 0,\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

Part B:

Level 2 Mathematical Model

In this level, each manager position (node) k represents a specific manager node where the total tasks produced by the underlying employees is aggregated. The model assigns one manager to each node in order to process the accumulated workload. Accordingly, the number of managers is assumed to be equal to the number of nodes, i.e., M = K. The workload (L) at each node k, the total demand (D), and the effective capacity (E) are defined as follows:

$$L_k\left(t\right)=\sum _{j\in \mathrm{node}\left(k\right)}\sum _{i=1}^N{P}_{ij}\left(t\right)x_{ij}\left(t\right)$$

(10)

$$D_k\left(t\right)=L_k\left(t\right)+B_k\left(t\right)$$

(11)

The total demand $D_k\left(t\right)$ at each position node k represents the cumulative workload that must be processed by the manager during time step t. It is defined as:

$L_k\left(t\right)$ (Inflow): The new workload generated by the employees assigned to node k at the current time step.

$B_k\left(t\right)$ (Stock): The backlog workload was transferred from the previous time period.

If the assigned manager’s capacity is insufficient to clear the current workload, the remainder is added to the demand of the subsequent period.

The effective capacity $E_{mk}\left(t\right)$ is computed as:

$$E_{mk}\left(t\right)=C_m·{\displaystyle \frac{P_{mk}\left(t\right)}{100}}$$

(12)

where

• $E_{mk}\left(t\right)$: The effective capacity of manager m when assigned to node k at time step t.
• $C_m$: The baseline capacity of manager m.
• $P_{mk}\left(t\right)\in [0,100]$: The performance of manager m when assigned to node k at time step t.

Objective Function: The objective function at Level 2 minimizes the total backlog across all processing nodes:

$$\underset{y\left(t\right)}{min}\sum _{k=1}^K\sum _{m=1}^M{y}_{mk}\left(t\right)max\left(0,D_k\left(t\right)-E_{mk}\left(t\right)\right)$$

(13)

Constraints: The optimization is subject to the following constraints to ensure a valid 1-to-1 matching between managers and processing nodes:

$$\sum _{k=1}^K{y}_{mk}\left(t\right)=1\forall m=1,\dots ,M$$

(14)

$$\sum _{m=1}^M{y}_{mk}\left(t\right)=1\forall k=1,\dots ,K$$

(15)

$$y_{mk}\left(t\right)\in \{0,1\}\forall m=1,\dots ,M,\forall k=1,\dots ,K$$

(16)

Part C:

System Dynamics and State Update

After calculating the optimal assignments $x_{ij}\left(t\right)$ and $y_{mk}\left(t\right)$ for the current period, the system transitions to the next state. This dynamic update includes the calculation of the completed tasks and the change in performance due to the resistance to change (RtC).

• Workload Output and Backlog Update

The actual workload processed ($Pro{c}_k\left(t\right)$) at each position node k is limited by both the accumulated demand and the assigned manager’s effective capacity:

$$Pro{c}_k\left(t\right)=\sum _{m=1}^M{y}_{mk}\left(t\right)min\left(D_k\left(t\right),E_{mk}\left(t\right)\right)$$

(17)

To assess the overall effectiveness of the organization and the impact of the management process, the results of all nodes are summarized in a single indicator: Total Processed Work ($Pro{c}_{total}$). This index represents the total volume of tasks successfully completed at all position nodes at time t and is the basic measure of organizational performance.

$$Pro{c}_{total}\left(t\right)=\sum _{k=1}^{K}Pro{c}_k\left(t\right)$$

(18)

Any unfinished tasks are recorded as pending for the next period. The backlog $B_k(t+1)$ is updated as the difference between total demand and processed output:

$$B_k(t+1)=D_k\left(t\right)-Pro{c}_k\left(t\right)$$

(19)

Total System Backlog ($B_{total}$): The total system backlog is defined as the sum of pending tasks at all nodes. An increase in $B_{total}$ over time indicates that managers are unable to keep up with the workload.

$$B_{total}(t+1)=\sum _{k=1}^K{B}_k(t+1)$$

(20)

2.

Performance Update Over Time

The performance update step is a significant part of the proposed method. The resistance of employees affects how human resources perform. The performance value associated with each assignment at the next time step ($t+1$) is calculated as follows:

For employees:

$$P_{ij}(t+1)=max\left(0,P_{ij}\left(t\right)-R_{ij}\left(t\right)\right)$$

(21)

For managers:

$$P_{mk}(t+1)=max\left(0,P_{mk}\left(t\right)-R_{mk}\left(t\right)\right)$$

(22)

The use of the operator $max(0,·)$ ensures that performance scores remain non-negative and unrealistic values are avoided.

The Total Managerial Performance Level ($P_{M,total}$) measures the overall performance of assigned managers.

$$P_{Mtotal}\left(t\right)=\sum _{m=1}^M\sum _{k=1}^K{y}_{mk}\left(t\right)P_{mk}\left(t\right)$$

(23)

3.2. Algorithmic Implementation of the Hierarchical CoMoRe Method

Initially, when organizational change begins, the first allocation achieves maximum performance by assigning tasks to employees and responsibilities to managers, respectively. At this stage of the first allocation, Equation (5) is applied to assign a specific task to each employee to achieve maximum performance. Next, Equation (13) is applied to maximize manager performance by minimizing unused capacity, assigning each manager a specific node of responsibility. It should be noted that at this initial stage ($t=0$), it is assumed that there is no backlog of pending tasks. Therefore, the initial backlog of the system is zero ($B_k\left(0\right)=0$). After this point, RtC begins to appear, which systematically reduces the performance of the human resources at both hierarchical levels. The innovation of the proposed method is based on the continuous monitoring of these performance variances at regular intervals and the reallocation of the human resources to reduce the organizational effects.

From a computational perspective, the proposed method decomposes the hierarchical resource reallocation problem into two interdependent assignment subproblems that are solved sequentially at each time step. First, a skill-constrained employee-to-task assignment is optimized at Level 1 in order to maximize operational performance. The resulting operational output is then aggregated into node-level workload and combined with any existing backlog to define the total managerial demand. Second, a manager-to-node assignment is optimized at Level 2 in order to minimize unserviced workload under dynamically updated effective capacity constraints. In this way, the two levels are algorithmically coupled over time, since the output of Level 1 determines the demand of Level 2, while the unmet demand of Level 2 is propagated forward as backlog and affects the next optimization cycle.

To implement the proposed algorithm, the following steps are performed:

Step 1:

At $t=0$, the initial performance values for employees ($P_{ij}\left(0\right)$) and managers ($P_{mk}\left(0\right)$) are defined. The employee-level matrices are of dimensions $N\times N$, while the managerial-level matrices are of size $M\times K$. The binary employee qualification matrix $q_{ij}\in \{0,1\}$ and the base managerial capacities $C_m$ are randomly generated (with initial values at $t=0$). Based on the capacities and initial performance, the effective capacity $E_{mk}$ is calculated, using Equation (12). The initial system backlog is set to zero ($B_k\left(0\right)=0$). Also the RtC is initialized to zero in matrices $R_{ij}\left(t\right)$ and $R_{mk}\left(t\right)$.

Step 2:

The allocation of employees to tasks is optimized using the Hungarian algorithm, aiming to maximize the objective function of Equation (5) and satisfying the constraint of Equations (6)–(8).

Step 3:

Based on the optimal Level 1 allocations determined in Step 2, the workload generated at each managerial node $L_k\left(t\right)$ is calculated using Equation (10). The total demand $D_k\left(t\right)$ for each node is then computed by adding the new workload to any existing backlog $B_k\left(t\right)$ from the beginning of the current period using the Equation (11).

Step 4:

A second application of the Hungarian algorithm is implemented for the management layer. Managers are assigned to nodes ($y_{mk}\left(t\right)$) by solving Equation (13), which minimizes the pending workload while using the updated active capacity $E_{mk}\left(t\right)$ as a decision criterion.

Step 5:

The values of resistance to change ($R_{ij}\left(t\right)$) exhibited by each employee for each task are randomly generated and stored in an $N\times N$ matrix. Similarly, the resistance values exhibited by each manager for each responsibility node ($R_{mk}\left(t\right)$) are randomly generated and stored in an $M\times K$ matrix.

Step 6:

After assignments are completed at both levels, the actual processed work $Pro{c}_k\left(t\right)$ is calculated by Equation (17). The unserviced part of the demand is carried over as the new backlog $B_k(t+1)$ for the next period, as given by Equation (19).

Step 7:

The new performance values for the next time step ($t+1$) are recalculated for both employees and managers using Equations (21) and  (22). Once computed at the current time step, these values ($B_k(t+1)$, $P_{ij}(t+1)$, $P_{mk}(t+1)$) are carried forward and used as inputs in Steps 2–4 of the next time step ($t+1$).

Step 8:

If the change period T has not been completed, the algorithm proceeds to the next time step ($t\leftarrow t+1$) and returns to Step 2 to execute a new loop of calculations.

Step 9:

Once the change period T is fully complete, the algorithm terminates. All Key Performance Indicators (KPIs) are then calculated, including the Total Processed Work ($Pro{c}_{total}$), Total System Backlog ($B_{total}$), and Total Managerial Performance ($P_{Mtotal}$). The indicators are summarized for all time steps to evaluate the overall success and performance of the change strategy. The above indicators are computed using Equations (18), (20) and (23).

The corresponding pseudocode follows as Algorithm 1.

Algorithm 1 Hierarchical CoMoRe with Skill Constraints and Managerial Layers

1: Input: $N,M,K,T,q_{ij},C_m,P_{ij}\left(0\right),P_{mk}\left(0\right)$   2: Output: Global KPIs ($Pro{c}_{total},B_{total},P_{Mtotal}$)   3: $t\leftarrow 0$   4: $B_k\left(0\right)\leftarrow 0,\forall k$   5: $R_{ij}\left(0\right)\leftarrow 0,R_{mk}\left(0\right)\leftarrow 0$   6: Calculate $E_{mk}\left(0\right)=C_m·{\displaystyle \frac{P_{mk}\left(0\right)}{100}}$   7: while $t<T$ do   8:     Solve Hungarian Algorithm for $x_{i,j}\left(t\right)$ to maximize, subject to $q_{ij}$   9:     Calculate $L_k\left(t\right)$ 10:     $D_k\left(t\right)\leftarrow L_k\left(t\right)+B_k\left(t\right)$ 11:     Update effective capacities $E_{mk}\left(t\right)$ 12:     Solve Hungarian Algorithm for $y_{mk}\left(t\right)$ to maximize 13:     Randomly generate RtC matrices $R_{ij}\left(t\right)$ and $R_{mk}\left(t\right)$ 14:     Calculate $Pro{c}_k\left(t\right)$ 15:     $B_k(t+1)\leftarrow D_k\left(t\right)-Pro{c}_k\left(t\right)$ 16:     $P_{ij}(t+1)\leftarrow max(0,P_{ij}\left(t\right)-R_{ij}\left(t\right))$ 17:     $P_{mk}(t+1)\leftarrow max(0,P_{mk}\left(t\right)-R_{mk}\left(t\right))$ 18:     $t\leftarrow t+1$ 19: end while 20: Aggregate $Pro{c}_{total},B_{total},P_{M,total}$ across all t 21: return Global KPIs

4. Experiments, Results and Discussion

Appropriate experiments were designed and conducted to evaluate the effectiveness of the proposed Hierarchical CoMoRe method. This section presents the graphical and numerical results of the experiment. Moreover, the application of the method is examined and the advantages resulting from the optimization of human resource reallocation during the change period, as well as from the integration of the hierarchical structure and quality constraints, are analysed. The simulation was developed in Python 3.12 using the Scientific Python (Spyder) environment within Anaconda Navigator. As presented in Section 3, but also in the original CoMoRe approach, human behaviour during change is considered dynamic and evolves over time. In particular, the process often begins with denial, which gradually itself as increases RtC. As a result, performance initially declines and may lead to a phase of low performance. Then acceptance gradually begins, resulting in recovery and significant improvement in performance. Finally, the system tends to stabilize in the new operating state. The experiments concerned a hypothetical organization implementing a strategic change. To evaluate the proposed hierarchical architecture, two main scenarios were simulated:

Experiment 1 (Small Scale): The company has 16 employees for 16 corresponding tasks ($N=16$) at the operational level (Level 1). To represent the quality of skills, employees are divided into 4 groups of qualifications and can only be assigned to the corresponding subsets of tasks, as dictated by the binary qualification mask. To manage the generated workload and systemic backlog, 4 managers ($M=4$) are distributed across 4 processing nodes ($K=4$) at the managerial level (Level 2).

Experiment 2 (Large Scale): The operational workforce and tasks increase to $N=160$, while the managerial level scales to ($M=40$) managers and the processing nodes to $K=40$. This allows for the study of system performance, backlog accumulation, and algorithm behaviour under heavier organizational loads.

As a reference point for modelling human behaviour during organizational change, the experiments in this study used the characteristic change curve presented in Panagiotopoulos and Chatzis [13]. This curve describes the timeline of employee performance in discrete time steps using the period of change from the initial to the final state of change. Specifically, performance starts at levels near the maximum value (100%) and then gradually declines, which in the early stages of change can reach approximately 30%, reflecting employee uncertainty and resistance. As the adaptation process progresses, there is a progressive recovery in performance.

To account for stochastic variability, a symmetric triangular distribution was applied to the values of the curve. The choice of this distribution allows the natural variation in human behaviour to be captured without distorting the basic dynamics of the change curve used as the basis for the model.

In this paper, the basic attributes of the Classical Change Management Model (CCMM) are adopted and used as a reference (ground-truth) curve for the design of new simulation experiments.

Specifically, Resistance to Change (RtC) is defined in discrete time steps, with $t=0$ corresponding to the baseline where resistance is considered zero, while RtC begins to appear from t = 1 and then varies during the change period.

Table 1. Limits of resistance for the symmetric triangular distribution $(l_t,m_t,r_t)$, (red indicates positive resistance; green indicates negative resistance).

TIME (t)	0	1	2	3	4	5	6	7
Resistance limits	(0, 0, 0)	(0, 10, 20)	(0, 22, 44)	(0, 15, 30)	(0, 9, 18)	(0, 7, 14)	(0, 6, 12)	(0, 4, 8)
TIME (t)	8	9	10	11	12	13	14	15
Resistance limits	(0, 0, 0)	(−8, −4, 0)	(−12, −6, 0)	(−20, −10, 0)	(−22, −11, 0)	(−30, −15, 0)	(−34, −17, 0)	(−34, −17, 0)
TIME (t)	16	17	18	19
Resistance limits	(−24, −12, 0)	(−16, −8, 0)	(−6, −3, 0)	(0, 0, 0)

gives, for each time step, the sampling limits $(l_t,m_t,r_t)$ of a symmetric triangular distribution, which are used to generate the RtC values. Based on these limits, random resistance values are generated at each t, which reflect both the general “change curve” and the natural variability of human reactions. In the present study, the RtC distribution parameters are defined for simulation purposes rather than derived from empirical observations. In real applications, data can be extracted from information systems to monitor employee performance at frequent intervals during periods of change, which can be used to calibrate the distribution parameters.

Furthermore, in Table 1, the colour coding reflects the behavioural significance of the RtC values: red corresponds to positive RtC values (higher resistance), while green corresponds to negative RtC values (greater acceptance and adaptation).

The generated RtC values are then used to dynamically update the performance at each time step, according to Equation (21), resulting in the simulated curve shown in Figure 3. It is important to note that Figure 3 does not directly represent RtC, but rather the performance curve resulting from the RtC values being incorporated into the corresponding calculations.

In Figure 3, the red dashed line with square markers corresponds to the Average Classic Change Curve, while the green scatter points represent random samples around the reference curve, reflecting the natural variability in human resource reactions during the change period. Finally, for the purposes of the proposed hierarchical approach, the reference curve has been adjusted to more fully cover the entire period of change, including the stabilization phase in the new operating state. For this reason, the final point t = 20 is included so that the stabilisation is clearly reflected, as it is not sufficiently highlighted in the original form of the classic curve. The same logic of RtC’s temporal evolution is applied at all levels of the model (employee level and manager level), with a corresponding dynamic update of performance at each time step.

4.1. Small Scale Experiment and Algorithm Implementation

The application of the proposed CoMoRe hierarchical algorithm begins at time $t=0$, which corresponds to the initial baseline and the start of the change period. In the first (small-scale) experiment, operational level (Level 1) consists of 16 employees and 16 corresponding tasks, resulting in the construction of a $16\times 16$ employee performance table $P_{ij}$. At the same time, for the managerial level (Level 2), 4 managers and 4 processing nodes are defined, with a corresponding $4\times 4$ managerial performance table $P_{mk}$.

In contrast to the original (single-level) formulation of CoMoRe, in the proposed model the assignment of employees to tasks is not completely free. A binary suitability mask $q_{ij}$ is used, which describes the constraints on qualifications, so that each employee can only be assigned to a suitable task subset. In the first experiment, the 16 employees are grouped into 4 qualification groups, and each group can only take on the corresponding subset of tasks.

At time $t=0$, the initial performance values of employees and managers are defined as high-performance starting conditions, while the initial systemic backlog is set to zero, i.e., $B_k\left(0\right)=0$ for all processing nodes k. In addition, the basic managerial capacities used to calculate the effective processing capacity at the second level are initialized.

As an initial condition of the algorithm, the performance of each employee for each possible task is randomly generated within the range 90–100 (i.e., 90–100%). An indicative set of values is presented in

Table 2. Initial performance matrix $P_{ij}(t=0)$ for each employee and task.

Performance ${\mathit{P}}_{\mathit{ij}}\mathbf{(}\mathit{t}\mathbf{=}\mathbf{0}\mathbf{)}$
	Tasks ($\mathit{j}$)
Employees ($\mathit{i}$)	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
1	93	90	91	99	95	91	97	92	96	92	98	96	93	98	91	90
2	91	91	91	95	100	99	90	94	93	90	93	95	99	96	97	91
3	92	100	92	94	99	91	96	97	97	99	91	100	95	99	96	99
4	96	98	92	97	91	97	96	94	91	94	90	96	94	93	91	93
5	93	95	92	100	99	94	94	90	97	96	100	94	96	91	100	92
6	96	97	95	99	98	99	100	98	97	97	90	94	96	90	92	97
7	100	97	96	99	96	95	98	93	95	100	100	90	97	100	95	95
8	97	99	90	92	93	90	94	95	90	95	98	95	92	96	92	97
9	91	92	93	96	98	98	94	100	97	90	92	93	98	99	93	91
10	90	100	95	94	100	99	91	90	100	100	93	93	95	98	95	100
11	94	94	93	91	98	93	97	99	93	96	96	99	93	90	96	90
12	92	99	98	91	99	98	90	90	92	100	99	90	94	96	100	92
13	93	91	99	92	99	97	95	91	99	99	91	97	98	93	93	97
14	90	94	97	92	92	96	90	95	91	99	92	99	95	90	92	99
15	96	98	97	97	99	91	99	93	96	93	92	97	99	95	94	96
16	95	91	100	91	92	99	99	99	91	99	98	94	96	99	90	95

.

Consequently, the initial performance table is combined with the $q_{i,j}$ binary qualification matrix mask, shown in

Table 3. Binary qualification matrix mask $q_{ij}$ at $t=0$ (equals to 1 if employee i is qualified to perform task j, and 0 otherwise).

Binary Qualification Matrix Mask ${\mathit{q}}_{\mathit{ij}}$
	Tasks ($\mathit{j}$)
Employees ($\mathit{i}$)	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
1	1	1	1	1	0	0	0	0	0	0	0	0	0	0	0	0
2	1	1	1	1	0	0	0	0	0	0	0	0	0	0	0	0
3	1	1	1	1	0	0	0	0	0	0	0	0	0	0	0	0
4	1	1	1	1	0	0	0	0	0	0	0	0	0	0	0	0
5	0	0	0	0	1	1	1	1	0	0	0	0	0	0	0	0
6	0	0	0	0	1	1	1	1	0	0	0	0	0	0	0	0
7	0	0	0	0	1	1	1	1	0	0	0	0	0	0	0	0
8	0	0	0	0	1	1	1	1	0	0	0	0	0	0	0	0
9	0	0	0	0	0	0	0	0	1	1	1	1	0	0	0	0
10	0	0	0	0	0	0	0	0	1	1	1	1	0	0	0	0
11	0	0	0	0	0	0	0	0	1	1	1	1	0	0	0	0
12	0	0	0	0	0	0	0	0	1	1	1	1	0	0	0	0
13	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1
14	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1
15	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1
16	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1

, to define the optimal assignment before the first optimization step.

At the same time, for the managerial level, a $4\times 4$ initial performance matrix of managers–nodes is created and randomly generated within the high initial performance range of 90–100 (i.e., 90–100%), presented in

Table 4. Manager Performance by Node $P_{mk}(t=0)$.

Manager Performance Matrix by Node ${\mathit{P}}_{\mathit{mk}}(\mathit{t}=0)$
	Nodes ($\mathit{k}$)
Managers ($\mathit{m}$)	1	2	3	4
1	90	100	95	97
2	98	100	95	98
3	98	91	98	100
4	91	97	91	90

, so that the system starts from a state of high managerial efficiency.

In addition, the base capacity of each manager ($C_m$) is initialized. In the small-scale experiment, each manager’s basic capacity is generated from a symmetric triangular distribution (minimum 380, mode 400, maximum 420), ensuring that managers have sufficient capacity to handle the maximum workload generated by employees ($4\times 100=400$ units). Based on the capacities ($C_m$) and initial performance ($P_{mk}$), the effective capacity $E_{mk}\left(0\right)$ is calculated, using Equation (12), as presented in

Table 5. Manager capacities $C_m$ and effective capacity matrix $E_{mk}(t=0)$.

Effective Capacity Matrix ${\mathit{E}}_{\mathit{mk}}(\mathit{t}=0)$
		Nodes ($\mathit{k}$)
Manager ($\mathit{m}$)	${\mathit{C}}_{\mathit{m}}$	1	2	3	4
1	387.0	348.3	387.0	367.6	375.4
2	390.0	382.2	390.0	370.5	382.2
3	388.0	380.2	353.1	380.2	388.0
4	397.0	361.3	385.1	361.3	357.3

.

According to Algorithm 1, in Step 2, the assignment of employees to level 1 tasks is optimized using the Hungarian algorithm to maximize overall performance, subject to the constraints of quality $q_{ij}$ of Equation (8). The masked employee performance matrix $P_{ij}(t=0)$ after applying $q_{ij}$ is shown in

Table 6. Masked Employees performance matrix $P_{ij}(t=0)$ after applying $q_{ij}$.

Performance ${\mathit{P}}_{\mathit{ij}}\mathbf{(}\mathit{t}\mathbf{=}\mathbf{0}\mathbf{)}$
	Tasks ($\mathit{j}$)
Employees ($\mathit{i}$)	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
1	93	90	91	99	0	0	0	0	0	0	0	0	0	0	0	0
2	91	91	91	95	0	0	0	0	0	0	0	0	0	0	0	0
3	92	100	92	94	0	0	0	0	0	0	0	0	0	0	0	0
4	96	98	92	97	0	0	0	0	0	0	0	0	0	0	0	0
5	0	0	0	0	99	94	94	90	0	0	0	0	0	0	0	0
6	0	0	0	0	98	99	100	98	0	0	0	0	0	0	0	0
7	0	0	0	0	96	95	98	93	0	0	0	0	0	0	0	0
8	0	0	0	0	93	90	94	95	0	0	0	0	0	0	0	0
9	0	0	0	0	0	0	0	0	97	90	92	93	0	0	0	0
10	0	0	0	0	0	0	0	0	100	100	93	93	0	0	0	0
11	0	0	0	0	0	0	0	0	93	96	96	99	0	0	0	0
12	0	0	0	0	0	0	0	0	92	100	99	90	0	0	0	0
13	0	0	0	0	0	0	0	0	0	0	0	0	98	93	93	97
14	0	0	0	0	0	0	0	0	0	0	0	0	95	90	92	99
15	0	0	0	0	0	0	0	0	0	0	0	0	99	95	94	96
16	0	0	0	0	0	0	0	0	0	0	0	0	96	99	90	95

and the resulting optimal allocation at $t=0$ is reported in

Table 7. Optimal employee-to-task allocation at $t=0$ and corresponding performance.

Employee i	Task j	Performance ${\mathit{P}}_{\mathit{i},\mathit{j}}\left(\mathbf{0}\right)$	Employee i	Task j	Performance ${\mathit{P}}_{\mathit{i},\mathit{j}}\left(\mathbf{0}\right)$
1	4	99	9	9	97
2	3	91	10	10	100
3	2	100	11	12	99
4	1	96	12	11	99
5	5	99	13	13	98
6	6	99	14	16	99
7	7	98	15	15	94
8	8	95	16	14	99
Total Initial Performance:					1562

.

The total performance at $t=0$ is computed as the sum of the performance values corresponding to the optimal assignment, with the detailed results provided in Table 7. As a theoretical upper bound, if all 16 employees achieved a performance of 100 on their assigned tasks, the maximum total performance would be 1600 ($100\times 16$). In the case we are examining here, the optimal allocation results in a total return of 1562.

The third step of the algorithm is based on the optimal level 1 allocations determined in step 2. The workload generated at each management node, $L_k\left(t\right)$, is calculated using Equation (10). Since the backlog is initialized to zero, $B_k\left(0\right)=0$, it follows that $D_k\left(0\right)=L_k\left(0\right)$ at the initial time step. For $t=0$, the computed values are summarized in

Table 8. Node demand $D_k\left(0\right)$ at $t=0$ (since $B_k\left(0\right)=0$, $D_k\left(0\right)=L_k\left(0\right)$) and optimal employee-to-task assignments.

Node k	Tasks $\mathit{j}\in \mathbf{Node}\left(\mathit{k}\right)$	Assigned Employees i	${\mathit{D}}_{\mathit{k}}\left(0\right)$
1	$\{1,2,3,4\}$	$\{4,3,2,1\}$	386
2	$\{5,6,7,8\}$	$\{5,6,7,8\}$	391
3	$\{9,10,11,12\}$	$\{9,10,12,11\}$	395
4	$\{13,14,15,16\}$	$\{13,16,15,14\}$	390
Total initial workload at $t=0$:			1562

.

A defining feature of the proposed Hierarchical CoMoRe framework is the dynamic relationship between the work performance of Level 1 employees and the resulting workload for Level 2 managers. In this hierarchical structure, an employee’s performance ($P_{i,j}$) does not simply represent the accomplishment of a task, but is directly translated into processing demand for the corresponding managerial node. Specifically, the cumulative operational output of all employees assigned to the tasks of node k constitutes the newly generated workload $L_k\left(t\right)$.

Consequently, high operational efficiency at the lower tier generates a proportionally high supervisory or administrative demand. As established, since the system backlog at $t=0$ is zero ($B_k\left(0\right)=0$), the initial demand $D_k\left(0\right)$ is strictly equal to the generated workload $L_k\left(0\right)$. So in this first time period the total initial performance of employees, amounting to 1562 units, translates directly into 1562 units of managerial workload, distributed across the four nodes. To maintain system stability, the appointed managers must have effective capacity ($E_{m,k}$) to process this incoming demand. Otherwise, the unserviced workload will be converted into system backlog for the next time period.

In the initial execution ($t=0$), in Step 4, the Hungarian algorithm is applied at the managerial level. Managers are assigned to processing nodes via the decision variable $y_{mk}\left(0\right)$ to minimize the total unserviced workload, as defined in Equation (13). To determine the optimal allocation, the algorithm first calculates a scoring matrix for all possible manager–node combinations. Each element of this matrix represents the negative value of the potential backlog (deficit), which is explicitly calculated as $-max\left(0,D_k\left(0\right)-E_{mk}\left(0\right)\right)$. These results, shown in

Table 9. Manager scores $y_{mk}\left(0\right)$ at $t=0$.

Manager m	Node $\mathit{k}=1$	Node $\mathit{k}=2$	Node $\mathit{k}=3$	Node $\mathit{k}=4$
1	$-37.7$	$-4.0$	$-27.4$	$-14.6$
2	$-3.8$	$-1.0$	$-24.5$	$-7.8$
3	$-5.8$	$-37.9$	$-14.8$	$-2.0$
4	$-24.7$	$-5.9$	$-33.7$	$-32.7$

, represent the unserviced workload. In this experiment, at the initial execution ($t=0$), the fact that all entries are negative indicates that no manager has sufficient capacity to fully satisfy the demand of any node, making some backlog unavoidable.

Based on this scoring matrix, the algorithm calculates the optimal binary assignment, represented by the decision variables $y_{mk}\left(0\right)$ in

Table 10. Optimal manager-to-node assignment at $t=0$ (Level 2).

Manager m	Node $\mathit{k}=1$	Node $\mathit{k}=2$	Node $\mathit{k}=3$	Node $\mathit{k}=4$
1	0	0	1	0
2	1	0	0	0
3	0	0	0	1
4	0	1	0	0

. A value of 1 indicates the selected manager–node combination that minimizes total unserviced workload.

Next, in Step 5,

Table 11. Summary of Level-2 assignment results at $t=0$, showing the processed workload $Pro{c}_k\left(0\right)$ and the resulting backlog $B_k\left(1\right)$ for each node.

Node	Initial Demand	Assigned Manager	Effective Capacity	Processed Workload	Backlog
$\mathit{k}$	${\mathit{D}}_{\mathit{k}}\left(\mathbf{0}\right)$	$\mathit{m}\left(\mathit{k}\right)$	${\mathit{E}}_{\mathit{m},\mathit{k}}\left(\mathbf{0}\right)$	${\mathit{Proc}}_{\mathit{k}}\left(\mathbf{0}\right)$	${\mathit{B}}_{\mathit{k}}\left(\mathbf{1}\right)$
1	386	2	382.2	382.2	3.8
2	391	4	385.1	385.1	5.9
3	395	1	367.6	367.6	27.4
4	390	3	388.0	388.0	2.0
Total System Backlog at $t=1$:					39.1

shows what actually results from these optimal assignments. At each node, the workload that is finally processed $Pro{c}_k\left(0\right)$ cannot exceed the available effective capacity of the manager assigned there. Any task that cannot be processed becomes backlog $B_k\left(1\right)$ and is carried over to the next period. $Pro{c}_k\left(0\right)$ is calculated from Equation (17) and $B_k\left(1\right)$ is updated from Equation (19), with $y_{m,k}\left(0\right)=1$ for the manager assigned to the node. With this optimal allocation, the total backlog passing at $t=1$ is kept to a an optimal (minimum) of 39.1 units.

This optimal allocation and the initial values of all parameters (for employees and managers) are used as a common “starting point” for both the proposed framework and the CCMM. That is, both models start at $t=0$ with exactly the same conditions across the hierarchy: the same initial performances, the same available capacities, and zero resistance. Furthermore, to ensure that luck does not influence the results, exactly the same resistance matrices are used in both models at each time step. Thus, any difference in the results is caused by the way each mode operates and not by different input data.

After the calculations in Step 5, the algorithm proceeds to Step 6 to calculate the RtC for employees and managers. As shown in Table 1, in the initial state (t = 0) the resistance is considered zero.

Therefore, in Step 7, the new performance values are recalculated for the next time step according to Equations (21) and (22). The performance capacities for $t=1$ remain unchanged. Therefore, as the simulation progresses to $t=1$, the Layer1 temporarily exhibits optimal initial performance. However, $t=1$ marks the beginning of the change implementation, resulting in resistance to change that affects both levels of the hierarchical model. As shown in Table 1, the algorithm samples the first non-zero resistance values from a symmetric triangular distribution with parameters (0, 10, 20). The realized resistance values for the managerial level at this time step are reported in

Table 12. Managerial Resistance to Change matrix $R_{mn}(t=1)$.

Resistance Values ${\mathit{R}}_{\mathit{mk}}(\mathit{t}=1)$
	Nodes ($\mathit{k}$)
Managers ($\mathit{m}$)	1	2	3	4
1	7	8	10	6
2	7	13	4	13
3	7	7	4	13
4	6	17	12	8

.

Using the same stochastic approach, RtC for employees is generated by random sampling from a triangular distribution. That is, for each assignment of employee i to task j, the algorithm samples a random resistance value $R_{ij}\left(1\right)$ from a triangular distribution defined by three limits $(l_t,m_t,r_t)$ as in Table 1. All $R_{ij}\left(1\right)$ values are collected in $N\times N$ matrix. The matrix for $t=1$ is shown in

Table 13. Employees Resistance to Change matrix $R_{ij}(t=1)$ sampled from $(0,10,20)$.

Resistance Values ${\mathit{R}}_{\mathit{ij}}\mathbf{(}\mathit{t}\mathbf{=}\mathbf{1}\mathbf{)}$
	Tasks ($\mathit{j}$)
Employees ($\mathit{i}$)	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
1	10	16	17	13	7	0	9	10	16	8	18	9	11	14	7	8
2	5	13	14	9	14	11	9	17	16	12	7	3	10	10	15	13
3	11	5	14	15	14	10	15	5	6	11	7	6	12	6	12	11
4	15	14	13	4	11	17	15	15	12	13	5	6	12	13	15	16
5	12	13	17	6	8	8	7	8	9	14	15	12	3	12	7	10
6	7	7	10	16	7	8	16	3	13	7	12	2	4	17	8	15
7	8	6	3	7	5	15	11	4	2	5	17	11	13	15	16	12
8	10	5	9	12	9	16	9	8	4	9	13	8	13	4	8	8
9	15	14	2	5	4	7	15	9	13	9	13	16	8	4	19	9
10	6	16	12	4	12	12	7	2	12	14	5	9	8	12	6	14
11	10	10	10	9	12	6	16	11	8	10	15	9	15	6	3	15
12	16	12	7	11	9	13	10	8	13	10	4	7	14	6	6	9
13	13	9	6	10	9	13	3	5	12	13	12	2	7	16	10	4
14	16	12	3	8	6	10	8	10	13	1	5	11	15	7	12	12
15	6	10	13	15	11	15	10	14	8	4	13	7	13	6	7	2
16	11	10	14	7	18	9	9	18	11	14	14	13	7	16	9	6

and shows that employees exhibit different levels of RtC.

Using the updated performance matrices using Equations (21) and (22) and the accumulated system backlog, the optimization procedure is repeated iteratively until the simulation ends at time T. At Level 1 (Operational), the Hungarian algorithm is re-applied to reallocate employees to tasks, maximizing total achievable performance subject to the quality constraints $q_{ij}$. The resulting output is calculated at the processing nodes to compute the workload $L_k\left(t\right)$ and the total demand $D_k\left(t\right)$. At Level 2 (Managerial), a second Hungarian optimization reallocates managers to nodes, accounting for the dynamically updated effective capacities $E_{mk}\left(t\right)$ and minimizing unserviced work. Finally, the processed workload $Pro{c}_k\left(t\right)$ is computed and any remaining unmet demand is carried forward as backlog $B_k(t+1)$.

The key innovation of Hierarchical CoMoRe is that it does not keep assignments “fixed” as changes progress. Instead, it continuously monitors the situation and anticipates resources at two levels: at the operational level (tasks/employees) and at the managerial level (managers/nodes). Thus, when performance drops and a backlog begins to accumulate, the model adjusts assignments to address the problem. This is a key advantage over CCMM, which keeps assignments the same and does not “react” when conditions change. As a result, Hierarchical CoMoRe makes better use of resources and reduces the risk of excessive workload accumulation, which could lead to a collapse of the operation and, ultimately, to the failure of change plans.

4.2. Small Scale Experiment, Results and Analysis

To thoroughly test how effective and reliable the Hierarchical CoMoRe is, simulations are run many times, from 100 to 100,000 repetitions. This shows whether the results are stable and do not change simply due to random, temporary fluctuations. Also, as the repetitions increase, it is checked whether the algorithm can withstand a larger scale and remains stable. The goal of the experiments is to show that HCoMoRe remains better than CCMM, regardless of how many repetitions are made.

For each scenario, the average total processed work per time step was calculated across all independent runs. Since the results obtained from 10,000 repetitions exhibited no significant deviation from those of 100,000 repetitions, it was concluded that the system had reached convergence, rendering further increases in the number of repetitions unnecessary. Figure 4 compares the average processed work of the proposed Hierarchical CoMoRe method with that of the CCMM, which is based on the classical change curve. Additionally,

Table 14. Total processed work per time step: Hierarchical CoMoRe vs. CCMM (100–100,000 reps).

	Total Processed Work
Repetitions	100		1000		10,000		100,000
Time ($\mathit{t}$)	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM
0	1540.90	1543.23	1542.69	1543.06	1542.53	1542.85	1542.81	1542.74
1	1543.20	1543.23	1544.10	1543.06	1543.79	1542.85	1544.11	1542.74
2	1412.66	1371.73	1412.45	1378.55	1412.06	1378.27	1412.41	1378.30
3	1096.36	1031.26	1116.23	1001.57	1117.76	1002.55	1118.08	1003.66
4	882.75	762.96	896.63	753.51	897.51	753.93	897.67	755.08
5	733.90	630.23	762.83	610.12	763.71	611.05	763.54	612.14
6	632.01	528.09	660.12	502.12	661.09	503.39	660.94	504.75
7	549.20	436.50	573.88	411.97	574.25	413.79	574.23	414.98
8	488.98	382.20	516.44	355.77	518.25	357.23	518.17	358.57
9	490.44	382.20	515.57	355.17	516.93	356.53	517.01	357.81
10	552.40	438.28	572.47	410.28	573.70	411.78	573.82	413.08
11	645.29	522.00	661.79	497.11	664.55	498.75	664.86	499.98
12	799.88	661.46	822.55	648.06	823.96	648.27	824.53	649.49
13	962.67	826.09	998.15	811.73	999.73	812.79	1000.21	814.29
14	1218.85	1067.42	1243.62	1039.21	1246.16	1039.82	1245.79	1041.03
15	1530.71	1291.86	1521.99	1296.34	1525.22	1297.07	1525.28	1298.41
16	1810.06	1546.64	1802.38	1550.10	1802.24	1554.01	1802.64	1555.40
17	1996.58	1738.03	1991.14	1729.25	1990.10	1732.40	1990.54	1734.44
18	2117.95	1859.21	2111.63	1844.62	2109.94	1848.37	2110.38	1850.55
19	2150.07	1889.20	2148.54	1882.49	2147.27	1885.89	2147.71	1887.93
20	2149.41	1889.20	2145.07	1880.81	2144.81	1884.03	2145.20	1886.12
Total	25,304.26	22,341.02	25,560.29	22,044.89	25,575.59	22,075.64	25,579.93	22,101.48

summarizes the corresponding numerical values used to generate the curves in Figure 4.

The comparison of the curves shows that Hierarchical CoMoRe has an advantage over CCMM because it can adaptively reallocate resources on two levels. At the beginning (from $t=0$ to $t=1$), the two models perform the same and process approximately 1500 units, as they start with the same initial assignments. The difference appears when resistance to change is high (from $t=2$ to $t=8$). In both models, performance declines, but HCoMoRe shows better results: at its lowest point $t=8$, it reaches approximately 500 units, while CCMM drops to approximately 350 units. HCoMoRe responds more quickly and allocates resources more efficiently. In the recovery phase (from $t=9$ to $t=20$), HCoMoRe increases more sharply and stabilizes around 2150 units towards the end (from $t=19$ to $t=20$). In contrast, CCMM stabilizes at a lower level, around 1900 units, because its static assignments continue to accumulate backlog.

Table 14 provides numerical data that is also shown in Figure 4. Particularly at 100,000 repetitions, it is clear that the adaptive redistribution of the Hierarchical CoMoRe significantly improves performance. At the lowest point of change ($t=8$), where resistance is at its maximum, CCMM drops very low (358.57 units), while Hierarchical CoMoRe maintains a significantly higher performance (518.17 units). Towards the end ($t=20$), Hierarchical CoMoRe also stabilizes at a better level (2145.20) compared to CCMM (1886.12). This is also evident in the total sum of the processed work: in 100,000 repetitions, Hierarchical CoMoRe reaches 25,579.93 units, while CCMM reaches 22,101.48. Therefore, overall, Hierarchical CoMoRe performs better. Finally, because the results at 1000, 10,000, and 100,000 repetitions are very close to each other, this shows that the model has essentially converged and the significant results do not change as the repetitions increase. This leads us to the practical conclusion that there is no reason to increase the number of repetitions significantly.

In addition to evaluate the effectiveness of the two models in practice,

Table 15. Comparison of accumulated backlog per time step for 100, 1000, 10,000, and 100,000 repetitions between the proposed Hierarchical CoMoRe method and the CCMM method.

	Accumulated Backlog
Repetitions	100		1000		10,000		100,000
Time ($\mathit{t}$)	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM
0	17.00	17.00	18.81	18.81	18.78	18.78	18.68	18.68
1	31.70	32.14	36.21	36.07	36.30	36.89	35.83	37.36
2	49.14	60.31	59.31	65.40	59.47	67.85	58.71	68.37
3	102.18	103.25	101.13	127.13	100.38	129.77	99.54	130.24
4	156.43	177.20	153.04	204.73	151.16	208.33	150.37	208.67
5	231.83	249.96	210.06	289.52	206.74	293.58	206.42	294.05
6	305.62	321.17	270.20	378.27	265.32	382.61	265.24	382.89
7	375.42	395.57	331.58	469.52	325.59	473.56	325.84	473.83
8	450.64	465.57	395.62	561.70	387.25	565.63	387.85	565.78
9	524.40	535.56	460.54	654.48	450.23	658.40	451.01	658.48
10	593.60	603.69	525.97	748.08	513.67	751.77	514.69	751.94
11	666.32	680.48	592.95	843.00	577.12	846.42	578.24	846.55
12	746.84	768.23	658.94	939.40	640.94	943.51	641.95	943.64
13	826.77	860.54	726.17	1039.25	705.91	1043.76	706.96	1043.92
14	896.12	947.22	794.89	1144.03	772.24	1149.05	774.05	1149.45
15	940.00	1079.26	867.77	1256.48	842.15	1260.98	844.37	1261.62
16	995.45	1210.92	942.19	1380.03	916.36	1380.24	918.52	1380.77
17	1052.77	1338.19	1019.82	1508.60	994.89	1505.37	996.97	1504.82
18	1108.92	1465.58	1100.49	1641.46	1077.43	1634.28	1079.12	1632.79
19	1177.45	1602.08	1184.99	1776.32	1163.21	1765.70	1164.48	1763.38
20	1246.64	1738.58	1272.96	1912.87	1251.46	1898.98	1252.35	1895.79

shows the backlog (pending tasks) that accumulates at each time step for different numbers of repetitions (100 to 100,000). At the starting point ($t=0$), both models begin with approximately the same, tiny amount of backlog. However, because CCMM holds static assignments and does not adapt when conditions change, it quickly begins to accumulate backlog. For example, at 100,000 repetitions, by $t=8$, the CCMM’s backlog reaches 565.78 units, while the Hierarchical CoMoRe keeps it lower, at 387.85 units. The biggest difference is seen at the end ($t=20$): the CCMM achieves a backlog of 1895.79 units, while the Hierarchical CoMoRe, as a result of adaptive reallocation, limits it to 1252.35 units. This shows that HCoMoRe is better and keeps the system more under control.

In summary, the results indicate that Hierarchical CoMoRe’s two-level adaptive reallocation not only enables faster recovery but also improves long-run stability by limiting sustained performance degradation and backlog accumulation. To complement these visual observations with a larger-scale assessment and quantify the framework’s impact under more realistic organizational complexity, we next apply the Hierarchical CoMoRe model to a larger company setting with 160 employees and 40 managers.

4.3. Large Scale Experiment and Algorithm Implementation

In the second experiment, we extend the organizational hierarchy to a hypothetical company with 160 employees and 160 corresponding tasks ($N=160$). To preserve the two-level structure, we introduce a management layer with 40 nodes ($M=40$). This larger setting is used to evaluate the effectiveness, efficiency, and computational scalability of the proposed Hierarchical CoMoRe framework under increased organizational complexity. The change process horizon, which captures behavioural reactions and resistance accumulation during change, is fixed at 20 time steps ($T=20$). Simulations are run for 100, 1000, 10,000, and 100,000 repetitions using the same stochastic sampling procedure as in the first experiment.

Table 16. Comparison of total processed work per time step for 100, 1000, 10,000, and 100,000 repetitions between the proposed Hierarchical CoMoRe and CCMM methods (Large-scale scenario: 160 employees, 40 managers).

	Total Processed Work (Large-Scale)
Repetitions	100		1000		10,000		100,000
Time ($\mathit{t}$)	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM
0	15,610.14	15,609.46	15,606.35	15,606.88	15,605.97	15,605.92	15,606.15	15,606.16
1	15,614.09	15,609.46	15,610.69	15,606.88	15,610.42	15,605.92	15,610.64	15,606.16
2	14,360.88	13,905.38	14,361.61	13,886.34	14,363.09	13,889.79	14,363.05	13,889.51
3	11,591.63	10,106.57	11,587.80	10,095.71	11,586.74	10,094.66	11,588.52	10,096.32
4	9474.98	7649.36	9487.27	7650.76	9481.92	7640.42	9484.00	7642.66
5	8186.77	6231.70	8199.96	6240.29	8192.48	6228.58	8194.99	6230.33
6	7186.64	5161.70	7202.05	5170.74	7193.59	5160.80	7196.56	5162.39
7	6332.44	4263.52	6352.31	4276.19	6343.76	4264.96	6346.69	4267.22
8	5787.46	3702.17	5806.86	3713.63	5797.47	3701.25	5800.02	3703.43
9	5787.25	3693.98	5806.62	3708.21	5797.21	3695.55	5799.77	3697.67
10	6358.57	4253.37	6379.67	4261.88	6370.56	4249.24	6373.32	4251.77
11	7273.94	5129.06	7289.04	5130.61	7279.95	5118.51	7282.95	5121.52
12	8872.07	6632.21	8890.89	6625.61	8877.36	6614.00	8881.98	6616.92
13	10,639.64	8278.96	10,662.71	8273.80	10,648.50	8263.80	10,652.32	8264.89
14	13,123.66	10,556.77	13,139.51	10,537.38	13,127.10	10,528.87	13,130.88	10,531.19
15	15,938.51	13,107.01	15,967.90	13,113.90	15,953.47	13,099.01	15,956.81	13,102.56
16	18,748.41	15,683.12	18,778.27	15,682.50	18,765.73	15,664.89	18,768.84	15,670.54
17	20,668.71	17,466.72	20,701.12	17,476.79	20,686.38	17,451.76	20,689.42	17,458.11
18	21,898.25	18,634.55	21,937.28	18,638.10	21,920.66	18,614.83	21,924.13	18,621.37
19	22,301.37	19,011.43	22,342.61	19,012.23	22,324.99	18,990.32	22,328.64	18,997.05
20	22,301.07	18,990.22	22,342.24	18,994.44	22,324.64	18,973.05	22,328.28	18,979.74
Total	268,056.48	223,676.72	268,452.75	223,702.87	268,252.01	223,456.13	268,307.95	223,517.48

present the total processed work per time step for Hierarchical CoMoRe and the static CCMM baseline.

Table 17. Comparison of Total Processed Work Improvement (TPWI) for 100, 1000, 10,000, and 100,000 repetitions between the HCoMoRe and CCMM methods (Large-scale scenario: 160 employees, 40 managers).

	Total Processed Work Improvement (%)
Time ($\mathit{t}$)	Repetitions 100	Repetitions 1000	Repetitions 10,000	Repetitions 100,000
0	0.00%	0.00%	0.00%	0.00%
1	0.03%	0.02%	0.03%	0.03%
2	3.28%	3.42%	3.41%	3.41%
3	14.69%	14.78%	14.78%	14.78%
4	23.87%	24.00%	24.10%	24.09%
5	31.37%	31.40%	31.53%	31.53%
6	39.23%	39.28%	39.39%	39.40%
7	48.53%	48.55%	48.74%	48.73%
8	56.33%	56.37%	56.64%	56.61%
9	56.67%	56.59%	56.87%	56.85%
10	49.49%	49.69%	49.92%	49.90%
11	41.82%	42.07%	42.23%	42.20%
12	33.77%	34.19%	34.22%	34.23%
13	28.51%	28.87%	28.86%	28.89%
14	24.32%	24.69%	24.68%	24.69%
15	21.60%	21.76%	21.79%	21.78%
16	19.55%	19.74%	19.80%	19.77%
17	18.33%	18.45%	18.53%	18.51%
18	17.51%	17.70%	17.76%	17.74%
19	17.30%	17.52%	17.56%	17.54%
20	17.43%	17.63%	17.66%	17.64%
Total	19.84%	20.00%	20.05%	20.04%

compares the Total Processed Work Improvement (TPWI) in percentage between the two methods across all time intervals while

Table 18. Comparison of accumulated backlog per time step for 100, 1000, 10,000, and 100,000 repetitions between the proposed Hierarchical CoMoRe method and the CCMM method (Large-scale scenario: 160 employees, 40 managers).

	Accumulated Backlog (Large-Scale)
Repetitions	100		1000		10,000		100,000
Time ($\mathit{t}$)	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM	HCoMoRe	CCMM
0	7.23	7.23	7.75	7.75	7.76	7.76	7.80	7.80
1	10.51	17.44	11.16	15.26	11.08	15.69	11.11	15.65
2	0.79	216.80	0.85	219.79	0.86	220.18	0.85	220.03
3	0.95	768.73	1.07	771.56	1.25	779.20	1.19	777.39
4	2.15	1458.08	2.09	1449.46	2.18	1472.12	2.09	1468.56
5	3.42	2207.08	3.00	2177.87	3.44	2216.31	3.25	2212.14
6	4.07	2981.31	4.11	2935.97	4.80	2988.91	4.54	2984.11
7	4.87	3778.09	5.19	3710.92	6.17	3780.62	5.90	3774.38
8	6.14	4580.62	6.59	4493.87	7.68	4582.47	7.43	4574.49
9	7.62	5391.34	8.22	5282.24	9.44	5390.03	9.21	5380.36
10	9.00	6204.51	9.76	6076.21	11.05	6203.95	10.80	6192.11
11	9.33	7020.86	10.88	6881.63	12.33	7028.71	12.05	7014.19
12	9.03	7857.83	11.44	7713.74	12.86	7877.00	12.52	7861.04
13	9.20	8728.57	11.70	8577.50	13.00	8755.26	12.59	8740.05
14	9.21	9631.39	11.58	9496.30	12.33	9687.66	12.05	9672.57
15	8.04	10,622.24	10.61	10,476.03	11.58	10,690.48	11.36	10,673.37
16	8.77	11,669.99	9.61	11,520.98	10.92	11,767.34	11.00	11,746.28
17	8.83	12,781.26	10.68	12,615.25	11.53	12,896.32	11.68	12,871.55
18	9.46	13,926.08	12.49	13,749.51	12.93	14,061.90	13.21	14,033.76
19	11.22	15,092.16	14.80	14,908.91	15.04	15,252.04	15.45	15,220.29
20	13.28	16,279.45	17.48	16,086.09	17.51	16,459.46	18.06	16,424.13

presents the corresponding accumulated backlog per time step. The contents of the Tables are explained in more detail below.

Table 16 shows the total work processed for a system consisting of 160 employees and 40 managers. The results clearly show that as the size of the organization increases, the absolute benefits of Hierarchical CoMoRe adaptive reallocation become more significant. Although the general pattern of behavior remains consistent with smaller-scale experiments, confirming the stability of the model, the performance gap during the change period is notable. At the peak of the RtC ($t=8$), the CCMM’s performance drops to 3703.43 units, while HCoMoRe successfully captures the RtC, achieving 5800.02 units. Furthermore, reaching the final stabilization point ($t=20$), HCoMoRe reaches 22,328.28 points per time step, far exceeding the 18,979.74 points of CCMM. Ultimately, this improved real-time adaptability translates into a huge cumulative advantage: Hierarchical CoMoRe processes a total of 268,307.95 units, compared to 223,517.48 for CCMM. This remarkable difference of almost 45,000 units clearly demonstrates that the proposed dynamic reallocation is not only scalable, but absolutely necessary to prevent serious bottlenecks in large enterprise change processes.

Table 17 compares the Total Processed Work Improvement (TPWI) in percentage between the two methods across all time intervals. The Total Processed Work Improvement is defined as follows:

$$TPWI={\displaystyle \frac{TP{W}_{HCoMoRe}-TP{W}_{CCMM}}{TP{W}_{CCMM}}}\times 100$$

(24)

where $TP{W}_{HCoMoRe}$ and $TP{W}_{CCMM}$ denote the total processed work achieved by the proposed Hierarchical CoMoRe and the classic CCMM methods, respectively.

As shown in Table 17 the Total Processed Work (TPWI) index clearly quantifies the potential advantage of Hierarchical CoMoRe over the CCMM approach. As demonstrated in Table 17, the Total Processed Work (TPWI) index is found to be most significant during the critical points of the change period ($t=8$ and $t=9$). At these points, the CoMoRe framework achieves an exceptional improvement of approximately 56.8%. This highlights the critical ability of the model to monitor in real time and assign human resources to nodes precisely when the system experiences the greatest drop in performance. As the change process and the system recovers, the improvement rate stabilizes. This ultimately leads to an extremely significant overall cumulative improvement of approximately 20% across all iteration levels. This steady 20% gain on total workload highlights the significant operational and business value of applying the Hierarchical CoMoRe model in large-scale organizational environments.

The most decisive evidence of Hierarchical CoMoRe’s superiority is presented in Table 18, which depicts the accumulated workload (backlog) per time step for the large-scale organizational structure. These results reveal a catastrophic failure of the static CCMM approach when applied to large-scale environments. While both models maintain a small backlog at the start of the simulation ($t=0$), CCMM’s inability to adapt to changes in RtC causes the backlog to grow uncontrollably. At the final time step ($t=20$), the traditional CCMM method results in a huge accumulated workload of 16,424.13 pending tasks. In contrast, Hierarchical CoMoRe successfully suppresses bottlenecks, maintaining a low final backlog of just 18.06 units across all iteration levels. The evidence indicates that in complex, large-scale business change process, dynamic resource reallocation is not simply an option for enhancing performance. It is an operational necessity to prevent a possible complete collapse of the system.

To address the practical constraints arising from multiple reallocations of human resources in real-world conditions,

Table 19. Impact of the reallocation threshold on the number of Employee and Manager Reallocations, Total Processed Output, and final backlog.

Reallocation Threshold (%)	Employee Reallocations	Manager Reallocations	Total Processed Output	Final Backlog
0%	586 (100.0%)	444 (100.0%)	268,308 (100.0%)	18
10%	562 (95.9%)	411 (92.6%)	268,088 (99.9%)	23
20%	521 (88.9%)	372 (83.8%)	267,647 (99.8%)	27
30%	470 (80.2%)	332 (74.8%)	266,926 (99.5%)	34
40%	411 (70.1%)	289 (65.1%)	265,855 (99.1%)	43
50%	345 (58.9%)	244 (55.0%)	264,281 (98.5%)	55
60%	273 (46.6%)	196 (44.1%)	261,974 (97.6%)	73
70%	195 (33.3%)	148 (33.3%)	258,387 (96.3%)	103
80%	111 (18.9%)	100 (22.5%)	252,782 (94.2%)	188
90%	33 (5.6%)	50 (11.3%)	243,259 (90.7%)	1872
100%	0 (0.0%)	0 (0.0%)	223,517 (83.3%)	16,424

presents a sensitivity analysis based on a “reallocation threshold.” In the real world, continuous reallocations of human resources are not always practical, even if they are mathematically optimal. Each reallocation requires time for coordination and information, causes a temporary loss of productivity when adapting to a new position or task, and creates administrative costs. For this reason, a threshold is necessary to allow reallocations only when a real benefit is expected and prevent small and insignificant reallocations. This threshold defines the minimum performance improvement required for a reallocations to be approved, acting essentially as a means of avoiding unnecessary reallocations.

At the 50% threshold, the organization performs only 58.9% of employee reallocations and 55.0% of manager reallocations compared with the 0% threshold case. At the same time, it preserves 98.5% of maximum performance and keeps the final backlog low (55). Furthermore, at the 90% reallocation threshold, the system keeps almost the same performance and the backlog remains relatively low (1872), with only 33 employee reallocations and 55 manager reallocations.

In contrast, increasing the threshold to 100% strictly prohibits all reallocations, returning the system to the static behaviour of CCMM, which leads to operational collapse with 16,424 pending tasks. This analysis demonstrates that the Hierarchical CoMoRe framework works well in extensive simulations, but the reallocation threshold results should be interpreted as a simulation-based evidence of a trade-off between performance and reallocation frequency, rather than as a direct proof of real-world effectiveness.

The proposed hierarchical framework solves two assignment problems at each time step, one at the employee level and one at the managerial level. As both subproblems are solved using the Hungarian algorithm, their theoretical time complexity is $O\left(N^3\right)$ and $O\left(M^3\right)$, respectively. Hence, the dominant complexity per time step is approximately $O(N^3+M^3)$.

Table 20. Execution time analysis for different organizational sizes.

Org. Size ($\mathit{N}\times \mathit{M}$)	Hungarian Time (s)	Remainder Time (s)	Total Time (s)	Hungarian Time (%)	Remainder Time (%)
$40\times 10$	0.0019	0.0031	0.0051	38.0%	62.0%
$160\times 40$	0.0085	0.0289	0.0374	22.6%	77.4%
$640\times 160$	0.1245	0.4688	0.5933	21.0%	79.0%
$1280\times 320$	0.4873	1.8384	2.3257	21.0%	79.0%

complements this theoretical result with an empirical execution-time analysis for different organizational sizes.

Table 20 reports the execution times of the Hungarian-based assignment component, the remaining update operations, and the total runtime for different organizational sizes. The results show that the total execution time increases with problem size, while remaining computationally manageable within the tested setting. For the largest tested case $(1280\times 320)$, the average total runtime was 2.3257 s. The Hungarian-based assignment component accounts for approximately 21% of the total runtime, while the remaining update operations account for the larger share of the computational cost. These results indicate that the proposed framework remains feasible for large organizational units, although the non-assignment update steps constitute the dominant cost in the current implementation.

5. Conclusions and Limitations

This study addressed the critical issue of managing resistance to change (RtC) within hierarchical organizational structures. Although previous studies have shown that continuous monitoring and reallocation models can reduce the effects of the “change curve,” they have mainly been implemented in flat organizational settings. By extending the CoMoRe methodology to a two-level Hierarchical CoMoRe framework, this paper suggests that effective change implementation benefits from coordinated interventions at both the operational and managerial levels, with constraints determined by task completion quality and capabilities. This study introduced Hierarchical CoMoRe, a two-level decision-making framework for implementing change under conditions of resistance to change (RtC), which combines continuous monitoring with two-level adaptive reallocation at the employee level (Level 1) and managerial staff (Level 2). The method incorporates quality constraints at the operational level and managerial capacity constraints at the managerial level, and solves both assignment problems in an optimal way at each time step using the Hungarian algorithm.

From an algorithmic standpoint, the contribution of the proposed method lies in the iterative coupling of these two assignment problems, where operational output, managerial demand, effective capacity, and backlog are dynamically updated over time under stochastic RtC-driven performance variation.

The simulation results indicate the effectiveness of the proposed framework within the tested setting. In large-scale scenarios, the static Classical Change Management Model (CCMM) was unable to adapt to performance variability, leading to a backlog exceeding 16,400 unfinished tasks. By contrast, Hierarchical CoMoRe maintained low backlog levels through continuous monitoring and adaptive reassignment. Overall, this dynamic mechanism increased the total workload processed during the change period by approximately 20%. In addition, the reallocation threshold analysis identified a practically attractive operating region: at a threshold of 50%, the framework avoids approximately 45% of total human resource reallocations while maintaining 98.5% of maximum performance. These findings suggest that effective change implementation does not necessarily require unrestricted reallocation intensity.

Despite its significant theoretical and practical contributions, the current model has certain limitations that open ways for future research. The mathematical formulation assumes a fixed organization size, without taking into account human resource turnover, medical leave, or new hires during the change phase. Also, it assumes a direct deterministic relationship between employee output and managerial workload.

Although the present formulation assumes fixed staff availability and single-task assignment per employee, the hierarchical framework can be extended to more general settings, such as staff turnover or multi-task allocation, by introducing time-varying workforce availability and modified assignment constraints. The validation is based exclusively on simulated scenarios and does not include real-world case studies or empirical datasets. While resistance to change was modelled using a stochastic triangular distribution to capture human variability, it should be noted that resistance in the real world can be highly contagious and interdependent across all human resources.

Future studies could incorporate network-based transmission models to simulate how RtC spreads horizontally among employees. Extending the hierarchical model to additional levels also constitutes an important challenge. Moreover, future research should examine the applicability of the proposed framework using real organizational data or explicitly considering the costs of implementation relating to continuous monitoring, data collection and personnel reassignment. Future research should also investigate the robustness of the framework under various RtC dynamics and across different departments and positions based on recent work on adaptive hierarchical decision frameworks.