Concurrent Task Orchestration: Hierarchical Trusted Collaborator Group Formation for Constrained Resource Allocation

1

Concurrent Task Orchestration: Hierarchical Trusted Collaborator Group Formation for Constrained Resource Allocation

arXiv:2610.33295v1 [cs.NI] 23 Oct 2026

Jiazhi Chen, Member, IEEE, Xianbin Wang, Fellow, IEEE, and Xuemin (Sherman) Shen, Fellow, IEEE

Abstract—Effective collaboration among resource-constrained mobile intelligent machines, such as Unmanned Aerial Vehicles (UAVs), is essential for the completion of complex tasks. However, concurrent task demands, limited distributed resources, and dynamic collaborator availabilities make it challenging to satisfy task-specific completion goals in diverse collaborative systems. To address these challenges simultaneously, we propose a new framework of trusted collaborator group formation and the supporting resource allocation strategy for concurrent task orchestration. Specifically, a collaborative task is decomposed into subtasks subject to dynamic resource availability and intersubtask dependencies. A task utility model is developed for collaborator group evaluation support subtask allocation according to task completion goals and unified value-risk analysis. Based on this model, concurrent task orchestration is formulated as a long-term utility maximization problem under α-fairness. To solve the problem efficiently, we develop a hierarchical matching strategy that first clusters tasks and collaborators into coarsegrained sets and subsequently performs fine-grained collaborator group formation and task allocation within matched sets. Task-specific trust is predicted through spatial-temporal Graph Neural Networks (GNNs) and embedded into a fairness-aware Deep Reinforcement Learning (DRL) framework to continuously update the matching policies. Simulation results demonstrate that the proposed strategy improves concurrent task completion performance by 22% over representative baselines under resource constraints. Index Terms—Task orchestration, trust, collaborator group, graph neural networks, deep reinforcement learning, fairness.

I. I NTRODUCTION

E

MPOWERED by the rapid convergence of inherent communication and computing technologies, future wireless networks will support a plethora of applications, including smart manufacturing and intelligent transportation systems, which involve increasingly complex collaborative tasks such as multi-robot assembly or vehicle platoon control [1]. Amidst the expeditious technological evolution, limited resources available at each device and growing heterogeneity among This work was supported in part by the Natural Sciences and Engineering Research Council of Canada (NSERC) Discovery Grants Program under Grants RGPIN-2024-05720 and RGPIN2026-05399, and in part by the Canada Research Chairs Program under Grant CRC-2023-00336. (Corresponding author: Xianbin Wang.) Jiazhi Chen and Xianbin Wang are with the Department of Electrical and Computer Engineering, Western University, London, ON N6A 5B9, Canada, (e-mails: jche629@uwo.ca, xianbin.wang@uwo.ca). Xuemin (Sherman) Shen is with the Department of Electrical and Computer Engineering, University of Waterloo, Waterloo, ON N2L 3G1, Canada (e-mail: sshen@uwaterloo.ca).

tasks necessitate intelligent and reliable collaboration among connected machines for effective task completion [2]. For instance, a group of connected intelligent machines (e.g., Unmanned Ground Vehicles (UGVs)) with computing resources and communication capabilities, could be selected to handle tasks delegated from other resource-constrained intelligent machines (e.g., Unmanned Aerial Vehicles (UAVs)) [3]. However, selecting suitable collaborator groups is difficult due to intricate requirements for capability and reliability. A. Motivation Given the heterogeneity and complexity of future collaborative systems, achieving efficient concurrent task orchestration through effective collaboration among intelligent machines under stringent resource constraints can be extremely challenging. This challenge primarily stems from the trade-off between meeting diverse requirements of concurrent tasks, possibility of involving different groups of collaborators for one same task, and drastically increased complexity to optimize overall system efficiency under fairness considerations. From the perspective of an individual task execution, both the task decomposition into subtasks and the selection of a group of collaborators jointly entail task completion value and risks. On the one hand, task completion value is fulfilled through meeting diverse task completion goals such as latency and energy consumption requirements [4], thus imposing intricate criteria on how tasks are decomposed and collaborator groups are selected. Proper task decomposition supports fine-grained collaboration and aligns subtasklevel completion goals with available resources. However, when task completion goals are ambiguously defined and trade-offs between competing goals are improperly balanced, the effectiveness of best-effort strategies such as Quality-ofService (QoS)-based task offloading is significantly reduced [5]. Moreover, attacks launched by malicious machines, such as illegitimate collaborators [6] or eavesdroppers [7], further degrade task completion value. On the other hand, dynamic task requirements and varying collaborator conditions introduce significant uncertainty for collaborator group formation and task allocation, thus increasing risks for task completion [8]. While some existing approaches such as heuristic-based task offloading select suitable collaborator groups, they often rely on static and complete system information [9], [10], making them ineffective in highly dynamic scenarios.

2

From the perspective of system orchestration, sharing limited resources of all collaborators among concurrent tasks remains a major challenge in guaranteeing the task completion value and tolerable risks for each task. Specifically, diverse task requirements induce increased dynamics in resource requirements, thereby intensifying uncertain contention among concurrent tasks for limited resources. This uncertainty in resource contention is eventually translated into unpredictable task completion outcomes and value. Thus, effective orchestration of concurrent tasks is needed to allocate limited resources across all completing tasks, aiming to maximize the collective task completion value and minimize associated risks simultaneously. Existing strategies typically formulate concurrent task orchestration as an optimization problem aiming to maximize the cumulative utilities of all concurrent tasks [11]. However, such objectives may lead to disproportionate outcomes, where some tasks could dominate allocated resources while others are persistently underserved. While short-term fairness is often unattainable under resource constraints, enforcing long-term fairness, i.e., fair task allocation over time, is essential to prevent persistent resource monopolization. Task-specific trust serves as a goal-achieving mechanism to direct the selection of reliable collaborators aligned with diverse completion goals of tasks [12]. We extend this concept from a single collaborator evaluation to a group evaluation, ensuring collective capability and reliability of collaborator groups in meeting the global requirements of tasks. Machine Learning (ML) supports adaptive collaborator group selection in dynamic environments by learning complex relationships between task requirements and collaborator conditions [13]. Among ML algorithms, Deep Reinforcement Learning (DRL) particularly supports sequential decision-making under complexity and dynamics, making it well-suited for optimizing long-term outcomes [14], [15]. Thus, the integration of taskspecific trust and DRL facilitates the automatic formation and matching of reliable collaborator groups aligned with evolving task goals. However, while DRL performs well under fully observable environments, partial observability of system states complicates such integration. Moreover, DRL typically maximizes long-term rewards, i.e., the cumulative utilities of all tasks [16], without considering long-term fairness, leading to imbalanced resource allocation among tasks. In addition, DRL model training in large-scale systems often becomes time-consuming and suffers from slow convergence [3], [17]. Based on these observations, an effective concurrent task orchestration strategy should jointly account for heterogeneous task completion goals, dynamic collaborator conditions, scalable group formation, and long-term fairness, rather than optimizing these aspects in isolation B. Related Work Reliable task orchestration in dynamic collaborative systems requires trust-aware collaborator selection and fair resource allocation. Accordingly, we review trust-based, learning-based, and fairness-aware task orchestration. 1) Trust-Based Task Orchestration: Trust has become increasingly important in orchestrating tasks, especially when security threats are involved. Beyond using trust scores derived

from historical task success and responsiveness to defend against internal attacks in task orchestration [18], some studies have leveraged such scores and their resulting trust-based rankings for service provider selection and task offloading [19]–[22]. For graph-structured tasks, [12] formulated the task orchestration problem as graph matching optimization to select an optimal set of trusted collaborators for task completion. However, the trust evaluation methods in this work is sensitive to weight settings of different trust factors and depend on prior knowledge, rendering it susceptible to inaccurate or biased evaluations. ML predict trust by capturing specific patterns in trust-related data [23], enabling automatic weight learning and achieving high accuracy with sufficient data. While Graph Neural Networks (GNNs) enable end-to-end trust evaluation from raw graph data [24], [25], existing methods are typically designed for fixed graph structures and static trust, limiting their ability to model dynamically evolving, task-specific relationships and incurring high training overhead in large-scale systems, without supporting group-level, taskspecific trust. 2) Learning-Based Task Orchestration: Motivated by the capability of DRL for automatic decision-making, extensive studies have been conducted to incorporate DRL in task orchestration [3], typically categorized into value-based and policy-based methods. For instance, Deep-Q-Network (DQN) learns the control policy via value function optimization [26], whereas deep deterministic policy gradient (DDPG) estimates policy gradients to directly optimize the control policy [27]. However, these DRL methods rely on complete state information and neglect interactive dependencies between agents. To address these limitations, recent efforts have shifted toward state abstraction techniques, with GNN emerging as a powerful tool for modeling structural and temporal dependencies to boost training, such as adopting GNN to encode cluster topology or extract inter-subtask dependencies [11]. However, these GNN-based DRL assume fully observable and trustworthy environments, reducing adaptability to unseen task structures, thus incurring high training overhead. Some studies integrate trust into DRL [28], [29] by leveraging historical trust to guide decision-making. However, in these works, trust is treated as an auxiliary, task-agnostic variable within standard DRL focused on reward maximization, without capturing taskspecific features and long-term fairness. 3) Fairness-Aware Task Orchestration: Building on existing fairness metrics, such as Jain’s index, entropy function, and min-max ratio, fairness-aware task orchestration has been widely explored in network optimization. Recent method in [10] overlooks long-term variations in task requirements and resource conditions and simplifies fairness optimization through convex assumptions, which is unrealistic in practical scenarios. To guarantee long-term fairness, [9] and [30] proposed dynamic resource allocation algorithms that rely on current system states without assuming prior distribution knowledge. However, these studies focus on specific fairness criteria (e.g., max-min or proportional fairness) rather than a general and tunable formulation such as α-fairness, which encompasses diverse system fairness objectives. Furthermore, various DRL algorithms have been applied to fair task or-

3

chestration in domains such as cognitive radio networks [31], yet their heuristic design restricts their adaptability to αfairness in optimization. Some DRL algorithms have shown potential in optimizing α-fairness [32]. However, they depend on Monte Carlo-based gradient estimation, resulting in slow convergence and remain decoupled from trust-aware and hierarchical decision-making.

ground eavesdroppers (Eves) A = {1, . . . , A} intercepting Air-to-Ground (A2G) communications [15], [33]. For UAV m, Ñ denotes the UGVs within its communication range. Each UAV continuously generates tasks over T = {1, . . . , T } and offloads them to UGV groups, while nearby Roadside Units (RSUs) collect task and collaborator information for decisionmaking. Major notations are summarized in Table I.

C. Contributions Motivated by these observations, we propose a fairnessaware concurrent task orchestration strategy that jointly performs trusted collaborator group formation and task allocation under dynamic and resource-constrained conditions. The contributions of this paper are summarized below. • We design a dynamic task utility model, rather than relying solely on static performance metrics, to guide collaborator group formation and task allocation aligned with diverse task completion goals. Tasks are decomposed into limited subtasks under resource constraints while preserving intersubtask dependencies, and collaborator groups are evaluated via a unified value-risk task utility that captures both goal satisfaction and deviation under dynamic conditions. Based on this task utility model, concurrent task orchestration is modeled as a long-term average utility maximization problem under α-fairness, enabling joint optimization of performance and fairness beyond conventional formulations. • We develop a hierarchical matching strategy that forms and matches trusted collaborator groups in a coarse-to-fine manner for scalable and adaptive task orchestration under long-term utility optimization. Instead of selecting individual collaborators, the strategy models group-level capability and reliability for task completion. To improve scalability in largescale systems, tasks and collaborators are first clustered into coarse-grained sets based on feature similarity, within which fine-grained group formation and subtask allocation are performed, reducing mismatches between dynamic task specifics and varying collaborator conditions. • To support the hierarchical matching strategy, we integrate task-specific trust prediction with fairness-aware policy learning into a unified framework. Specifically, GNNs infer taskspecific trust by capturing spatial-temporal dependencies between tasks and collaborators across both coarse-grained and fine-grained levels. These trust representations are then embedded into a fairness-aware DRL framework to guide longterm matching policies. Each matching process is formulated as a Markov Decision Process (MDP), where predicted trust values serve as abstracted states and fairness-aware rewards are derived by adjusting task utilities based on fairness objectives and historical reward statistics. The remainder of this paper is structured as follows. Section II describes the system model and problem formulation. Section III details our proposed strategy. Simulation results are presented in Section IV, and Section V concludes the paper. II. S YSTEM M ODEL AND P ROBLEM F ORMULATION As shown in Fig. 1, we consider a collaborative system with UAVs M = {1, . . . , M }, UGVs N = {1, . . . , N }, and

Learning Task 1

A2A Task 3 Task 2

A2G

Match

V2I

Group 1 Group 3

V2V

Group 2

Collaborative System Support Task

Resource

UAV

Legitimate UGV

Malicious UGV

Ground Eves

Fig. 1. An illustration of the UAV-UGV collaborative system, where UAVs offload tasks to trusted UGV groups.

A. Modeling Tasks and Resources as Graphs Each task generated by UAV m is decomposed into subtasks and modeled as an undirected graph Gm = (Sm , Em , Wm ) to preserve inter-subtask dependencies [11], [34], where Sm = {sim |i ∈ {1, . . . , |Sm |}}, Em = ′ ′ ′ ii′ ′ {eii m |i, i ∈ {1, . . . , |Sm |}, i ̸= i }, and Wm = {wm |i, i ∈ ′ {1, . . . , |Sm |}, i ̸= i } denote subtasks, dependencies, and required contact durations, respectively. For M concurrent tasks, SM = ∪m∈M Sm = {sl |l = (i, m)} denotes the set of all subtasks. Interdependent subtasks require reliable V2V communication among collaborating UGVs. We therefore model the UGV platform as a resource graph GN = (N , EN , WN ), where EN contains one-hop V2V links and WN contains their exponential contact-duration rate parameters [11]. The resources of UGV n are represented by VMs Vn = {vjn |j ∈ {1, . . . , |Vn |}} [12], with different CPU capabilities. The complete resource set is VN = ∪n∈N Vn = {vk |k = (j, n)}. B. Modeling Value of Task Completion As introduced in Section I-A, the task completion value is the benefit derived from meeting diverse task completion goals. Accordingly, a tailored metric, Value of Task Completion [10], [35], is utilized to evaluate how effectively the selected collaborator group fulfills diverse task completion goals in a unified manner. As the task requestor can directly perceive the time and energy costs of completing its tasks, value of task completion comprises both the value of time and the value of energy. Besides, a nearby RSU transfers its locally perceived reliability of selected collaborator groups to task requestor, which is termed the value of reliability. Thus,

4

gain at 1 m, dA2G mn is the A2G distance, and η is the path loss exponent. Moreover, the data exchange time ∆τnn′ follows an opportunistic V2V contact model which obeys exponential distribution [11], where Pr(∆τnn′ ≥ ∆t|wnn′ ) = e−∆t×wnn′ ′ D′ ) ii im − ϕi m′ | + wm . and ∆t = | ϕDmn mn To assess whether the selected collaborator n meets tmax im , the value of subtask completion time is defined as ( tn 1 − tim if tnim < tmax max , im , time im (4) uim = n 0, if tim ≥ tmax im .

TABLE I M AJOR N OTATIONS AND D EFINITIONS Notation a ′

Definition An Eve, a ∈ A

′

′

eii m enn′ m n n̂ Om oim Qm Qx Qp Rm sim sp Um vk

A dependency (edge) between i and i , eii m ∈ Em V2V link between n and n′ , enn′ ∈ EN A UAV, m ∈ M A UGV, n ∈ N A collaborator within a collaborator cluster, n̂ ∈ Cy A set of completion goals of a task Gm A set of completion goals of a subtask sim Utility of individual task Gm Utility of a cluster centroid Averaged utility of all subtask within cluster Cx Risk of task completion A subtask of a UAV graph task, sim ∈ Sm A subtask within a task cluster, sp ∈ Cx Value of task completion An available virtual machine, vk ∈ VN

ii wm wnn′ wx→y wsp →n̂ xn im

ii ∈ W Required contact duration between i and i , wm m Contact-duration rate parameter, wnn′ ∈ WN Trust value between Cx and Cy Trust value between sp and n̂ Binary task offloading decision between sim and n

′

′

The overall completion time Tm of a task Gm is calculated based on the slowest subtask completion time tnim , denoted as Tm = max tnim . Therefore, the value of overall task 1≤i≤|Sm |

time completion time is denoted as Um =

′

the value of task completion for subtask sim and overall task Gm is formulated as energy unim = ς1 utime + ς3 ureliability , im + ς2 uim im

(1)

time energy reliability Um = ς4 Um + ς5 Um + ς6 Um ,

(2)

and respectively, where ς1−6 are weighting parameters for different task objectives. The task-level completion goals are max max , Θmax , Em Om = [Tm m ], while each subtask has oim = max max max [tim , eim , θim ]. The relationship between subtask goals and max overall task goals is defined as follows: Tm = max tmax im , 1≤i≤|Sm | P P |Sm | max |Sm | max max max = Em = i=1 eim , and Θm i=1 θim , where the slowest subtask determines task completion time, while the overall energy consumption and reliability requirements are obtained by aggregating corresponding subtask demands. 1) Value of Time: The completion time tnim includes transmission and computation delays, as well as V2V dataexchange delay when dependent subtasks are assigned to different collaborators:  ! Ñ  P P  Dim ρim Dim n  xim ϕmn + ∆τnn′ + fjn ,     n=1 n′ ∈Ñ ′ ′ tnim = (3) if eii m = 1, xin × xi′ n′ = 1, n ̸= n ,      Ñ  P  ρim ik  + Dim , otherwise, xnim ϕDmn  fjn n=1

where Dim and ρim denote the data size and required CPU cycles per bit, and fjn is the CPU frequency of VM vjn . As different values of fjn reflect diverse computing capabilities, the set fn = {fjn |j ∈ {1, 2, . . . , |Vn |}} denotes all available computing resources of UGV n. Besides, ϕmn = W log2 (1 + pmσg2mn ) indicates the data transmission rate between UAV m and the UGV n, where pm is the −η transmit power, W is the bandwidth, and gmn = g1 (dA2G mn ) represents the channel gain [33]. g1 is the reference channel

min

1≤i≤|Sm |

utime im .

2) Value of Energy: The UAV energy consumption for offloading sim includes transmission and channel-holding energy [7], which is given by   |Ñ | X pm Dim n n eim = xim + ℓim , (5) ϕmn n=1 where ℓim denotes the energy consumed during the channel holding period after transmitting subtask sim . Similar to the value of time, the value of energy for completing the subtask sim is determined by comparing the expected energy consumption emax im with the actual energy consumption enim , expressed as ( en if enim < emax 1 − eim max , energy im , im uim = (6) n 0, if eim ≥ emax im . The overall energy P consumption for offloading a task Gm is |Sm | n calculated as Em = i=1 eim and the corresponding value P|Sm | emax energy energy im of energy is denoted as Um = i=1 . max uim Em 3) Value of Reliability: In open and dynamic collaborative systems, adversarial infiltration is inevitable, posing security threats to task offloading and completion. We consider two security threats: malicious UGVs launching blackhole or onoff attacks [36], [37], and ground Eves intercepting UAVto-UGV transmissions [15], [33]. Accordingly, collaborator reliability combines identity authentication and transmission secrecy. Specifically, the identity of a selected collaborator n is verified through lightweight continuous authentication locally executed at RSUs [38], with the authentication accuracy ψn defined as the weighted probability of correctly authenticating the collaborator’s identity, given by ψn = 1 − (ϵ1 PF A + ϵ2 PM D ),

(7)

where PF A = Pr(e γnt̂ ̸= γnt̂ | ψ0 ) and PM D = Pr(e γnt̂ = γnt̂ | ψ1 ) denote the false alarm rate and misdetection rate, respectively, and ψ0 and ψ1 indicate whether n is legitimate or malicious, respectively. The authentication results at time t ∈ T are determined as follows:  ψ0 , if γ ent̂ = γnt̂ , ∀t̂ ∈ {1, 2, ..., t} ϕn (t) = , (8) ψ1 , if γ ent̂ ̸= γnt̂ , ∃t̂ ∈ {1, 2, ..., t} where γnt̂ and γ ent̂ denote the expected and actual access states toward nearby RSUs, respectively, within the

5

en = access time sequences γj = [γn1 , γn2 , . . . , γnT ]⊤ and γ [e γn1 , γ en2 , . . . , γ enT ]⊤ . (·)⊤ denotes vector transposition. The possibility of maintaining confidential transmission when selecting n for completing sim is quantified as ( sec δim Rmn sec if δim Rmn < Dim n Dim ηim = , (9) sec 1 if δim Rmn ≥ Dim Dim ρim is the maximum transmiswhere δim = tmax im − fjn sec sion time and Rmn =

min

||gma −ĝma ||≤∆g1 ||gna −ĝna ||≤∆g2

 + is ϕmn − maxϕma a∈A

na

pjam n

ĝna − ∆g2 characterize the worst-case channels, and denotes the jamming power. Based on (7) and (9), the reliability of the selected UGV n in completing subtask sim is denoted as n θim =

|Ñ | X

n xnim (ζ1 ψn + ζ2 ηim ),

|Sm |

Rm =

the worst-case achievable secrecy rate [15]. Here, ϕma = p g max max min W log2 (1 + jammminma 2 ), where gma = ĝma + ∆g1 and gna = p g +σ n

n max max n Z = w1 (tnim − tmax im ) + w2 (eim − eim ) + w3 (θim − θim ), otherwise, Z = 0, where w1 , w2 , w3 scale the deviation from task requirements without affecting the underlying risk formuenim and oim are normalized to lation. Note that all vectors in o a common scale between 0 to 1. The overall risk for completing Gm , denoted as Rm , considers both the risk of assigning different collaborators to individual subtasks and the compounded risk introduced by interdependencies between subtasks, given by

(10)

n=1

where ζ1 and ζ2 indicate the weight parameters that reflect the relative importance of authentication and secrecy. Due to varying sensitivities of subtasks to security threats, the reliability requirements for the selected collaborator differ. Therefore, the value of reliability of a subtask sim is designed to adapt to task-specific requirements, given by ( θn n max im if θim < θim , max , reliability uim = θim (11) n max 1, if θim ≥ θim .

X

|Sm |

wim rαnim +

(13) where wim indicates the relative importance of sim in Gm , reflecting task structure while preserving risk modeling. D. Problem Formulation To jointly capture the value and risk of collaborator group selection, the utility of individual task Gm is needed, given by Um , where Um and Rm denote the obtained value Qm = ϱ+R m and perceived risk for completing Gm , respectively, and the constant ϱ = 1 indicates that the impact of Um and Rm is balanced equally, with Rm reducing Qm proportionally to its magnitude in a scale-invariant manner. However, task requirements and collaborator conditions vary over time, the same collaborator group may yield different utility for identical tasks, motivating long-term average utility for stable decision-making. Given the individual task utility Um (t) Qm (t) = ϱ+R at time t, the long-term average task utility m (t) is obtained by T

1X Qm (t). T →∞ T t=1

Qm = lim

m

Dynamic task requirements and collaborator conditions introduce the risk of violating latency, energy, and reliability goals. Following the Risk of Task Completion metric in [39], inspired by Conditional Value at Risk (CVaR) [8], we define a task-specific trust threshold concerning dynamic subtask completion goals: the task requestor m announces each subtask trust threshold of 1 − αim , where αim = max max ξ1 tmax im + ξ2 eim + ξ3 (1 − θim ) ∈ (0, 1). 0 ≤ ξ1 , ξ2 , ξ3 ≤ 1 are weighting coefficients capturing the relative emphasis on different completion goals, with ξ1 + ξ2 + ξ3 = 1, and all completion goals are normalized to a common scale between 0 to 1. The risk of selecting collaborator n for completing subtask sim under the trust threshold of 1 − αim is evaluated as |Ñ | X  rαnim = xnim inf β + E[Z − β]+ , (12) n=1

β∈R

where β denotes an auxiliary variable with the same range as Z, R represents the set of all real numbers, and E is the expectation. Based on subtask completion goals oim and actual n enim = [tnim , enim , θim completion performance o ] of selecting n max n max max n collaborator n, when tim > tim , eim > eim , and θim > θim ,

′

ii n n eii m wm max(rαim , rαi′ m ),

i=1 i′ >i

i=1

The overall reliability of the selected UGV groups for P m| n completing Gm is calculated as Θm = |S θim and its value max Pi=1 |Sm | θim reliability reliability of reliability is denoted as Um = i=1 Θmax uim . C. Modeling Risk of Task Completion

′

XX

(14)

To incorporate fairness in concurrent task orchestration, we adopt an α-fair utility function to adjust Qm based on fairness preferences (α ≥ 0), with smaller α favoring efficiency and larger α enforcing fairness [40], given by ( 1−α x if α ̸= 1, 1−α U (x) = (15) log(x) if α = 1. Based on the above system models, we formulate the objective as maximizing the long-term average utility of concurrent tasks under fairness considerations through trusted collaborator selection X = [xnim (t)]1≤t≤T,1≤n≤N,1≤m≤M,1≤i≤|Sm | in resource-constrained collaborative systems, given by P : max X

s.t.

N X

xnim (t) = 1,

M X

U (Qm )

(16)

m=1

∀i, m, t ∈ |Sm | , M, T ,

(16a)

n=1 M |S m| X X

xnim (t) ≤ |Vn | ,

∀n, t ∈ N , T ,

(16b)

m=1 i=1

e−∆t×wnn′ ≥ µ, ′

′

∀xnim (t) × xni′ m (t) = 1, ′

′

∀n, n ∈ Ñ , n ̸= n , ∀eii m , m, t ∈ Em , M, T

(16c)

6

pm (t) = 0,

xnim (t) = 0,

∀i, m, t ∈ Sm , M, T , n ∈ / Ñ

(16d)

where xnim (t) = 1 denotes collaborator n is selected to complete subtask sim generated at time t, otherwise xnim (t) = 0. Constraint (16a) states that each subtask can be offloaded to only one UGV. Constraint (16b) limits the offloaded subtasks to exceed the available VMs of each UGV. Constraint (16c) ensures that when connected subtasks sim and si′ m of task ′ Gm are offloaded to different UGVs n and n , the probability of data exchange time ∆τnn′ exceeding ∆t must surpass a threshold µ while Constraint (16d) restricts UAVs to offload subtasks only to UGVs within their communication radius. Remark 1: Solving the mixed integer programming problem in (16) is extremely challenging due to 1) the difficulty of long-term average optimization, induced by inherent uncertainties from dynamic task requirements, varying collaborator conditions, and diverse attacks in collaborative systems; and 2) the need to maximize the total task utility of all concurrent tasks, while simultaneously ensuring long-term fairness in resource allocation and allowing short-term fairness variations due to system dynamics such as task urgency and limited resources. These challenges motivate the hierarchical strategy developed next to solve P . III. H IERARCHICAL T RUSTED C OLLABORATOR G ROUP F ORMATION AND TASK A LLOCATION To solve (16), we propose a hierarchical strategy for trusted collaborator group formation and task allocation under longterm fairness. As shown in Fig. 2, the framework consists of two core modules: 1) Hierarchical Task-Specific Trust prediction via GNNs (HTST-GNN) at coarse- and fine-grained levels, and 2) trust-embedded fairness-aware DRL for coarse-to-fine matching. Online inference is coordinated by nearby RSUs, while model training is performed offline and periodically. A. Hierarchical Task-Specific Trust Prediction via GNNs Dynamic task requirements and collaborator conditions directly affect the objective in (16), while representing all such factors cannot efficiently capture their interdependencies. We therefore use task-specific trust to abstract the value and risk of task-resource interactions. The proposed HTSTGNN dynamically coarsens tasks and resources and performs spatial-temporal aggregation to predict trust at both coarseand fine-grained levels. We model the collaborative system over time as a sequence of trust-guided bipartite graphs G(t) = (SM (t), N (t), E(t)) t̂ during time {1, 2, . . . , t}, where G t̂ = (SM , N t̂ , E t̂ ) belongs to G(t) → {G 1 , G 2 , . . . , G t }, ∀t̂ ∈ {1, 2, . . . , t}. Each st̂l ∈ t̂ SM , nt̂ ∈ N t̂ , and et̂sl →n ∈ E t̂ have time-varying features, i.e., subtask features Flt̂ = [ol (t̂), Dl (t̂), ρl (t̂), Gm (t̂)], ∀l = (i, m), i ∈ {1, 2, . . . , |Sm |}, m ∈ M, collaborator features Fnt̂ = [ϕn (t̂), pjam n (t̂), fn (t̂), GN (t̂)], and trust value wst̂ l →n ∈ W t̂ . The objective is to predict trust values at t + 1 by training a trust evaluation model on G(t) in a coarseto-fine manner, with coarse-grained prediction between task and resource sets followed by fine-grained prediction between subtasks and collaborators within matched sets.

1) Dynamic Coarsening Process: Dynamic coarsening partitions tasks into feature-similar sets to reduce taskcollaborator mismatches and the subsequent matching space. Definition 1 (Coarsening of Concurrent Tasks). Given the graph representation of individual task Gm , ∀m ∈ M, the
coarsening of concurrent tasks, referred to by C {Gm }m∈M , is the clustering of all subtasks SM based on subtask feature similarities, given by
C {Gm }m∈M ≜ (CM , EM ),

where CM = {Cx |x = {1, 2, . . . , X}}, X denotes the number of clusters, Cx represents the x-th cluster including one or more subtasks from different UAVs, i.e., Cx = {sp | p ∈ {1,P 2, . . . , |SMx |}} with features of cluster centroids 1 Fx = |SMx sp ∈Cx Fp , sp and Fp are the p-th subtask and | its features in Cx , respectively, SMx = ∪m∈M Smx , ∀Smx ⊆ Sm represents the subtasks assigned to Cx , and EM = {Em }m∈M denotes the set of subtask dependencies. Similarly, heterogeneous collaborator identities, secrecy capabilities, and computing resources motivate coarsening the UGV set as follows. Definition 2 (Coarsening of Distributed Resources). The coarsening of distributed resources, referred to by C (GN ), is a construction of different collaborator sets via clustering based on collaborator feature similarities, given by C (GN ) ≜ (CN , EN ),

where CN = {Cy | y = {1, 2, . . . , Y }}, Y denotes the number of clusters, and Cy represents the y-th cluster including one or more collaborators, i.e., Cy = {n̂ | n̂ ∈ P {1, 2, . . . , |Ny |}} with features of cluster centroids Fy = |N1y | n̂∈Cy Fn̂ , n̂ and Fn̂ are the n̂-th collaborator and its features in Cy , respectively, S Ny ⊆ N = n̂∈Cy Vn̂ denotes the set of UGVs belongs to the y-th cluster and Vn̂ indicates the set of VMs of n̂. Based on Definitions 1 and 2, K-means clustering [12] produces feature-similar task and resource sets, yielding the coarsened trust-guided bipartite graph GC (t) = (CM (t), CN (t), ECM →CN (t)), where t̂ t̂ , ECt̂ M →CN ) is a coarsened graph at t̂. , CN GCt̂ = (CM 2) Spatial-Temporal Feature Aggregation: After obtaining the coarsened trust-guided bipartite graphs, spatial-temporal feature aggregation is applied to capture both static and dynamic information in graphs GC (t). As nodes and edges in each GCt̂ have different attribute vector dimensions, the initial embeddings of coarse-grained subtask sets, collaborator sets, and their edges are obtained by transforming their raw features of the cluster centroid into a common vector space as 0 h0x = Wx · Fx , h0y = Wy · Fy , and ϖx→y = We · wx→y , where Wx , Wy , and We indicate the learnable parameter matrices, P P 1 respectively, wx→y = |SMx |×|N w sp ∈Cx n̂∈Cy sp →n̂ iny| dicates the edge weight (trust value) between Cx and Cy , and wsp →n̂ = 1 − (ξ1 tn̂p + ξ2 en̂p + ξ3 (1 − θpn̂ )) denotes the initial trust value between sp ∈ Cx and n̂ ∈ Cy , where ξ1 , ξ2 , ξ3 balance different task attributes in the initial trust estimation. To obtain spatial information for trust modeling in GCt̂ , we first learn latent representations of subtasks and collaborators by propagating and aggregating information from their neighbors [24]. At each layer l = {1, 2, . . . , L}, the process of the

7

a). Hierarchical Task-Specific Trust Prediction via Spatial-Temporal GNNs Coarse-Grained

GRU

Time

Trust

③

Objective Functions of Matching Actions

Coarse-Grained Level X

Fine-Grained| Level | X

 H* = arg max U (Qx )  L* = arg max   U (Qp ) H

Environment

Trust Relationship

Subtasks FineGrained

②

Actor

Results

GRU

Aggregation

GRU Aggregation Aggregation

①

CoarseGrained

Resources

Update Update Update

x =1

L

x

x =1 p =1

Update

States

Adjusted Reward

Resource Clustering

Task Clustering

GRU Aggregation Aggregation

CoarseGrained

Results

GRU

GRU Aggregation

Matching

Resources

Predicted trust value matrics

Update Update

Update

CoarseGrained Trust

Subasks

CoarseGrained

Spatial-to-Temporal

Fine-Grained

Dynamic Coarsening of Tasks and Resources

Update

TD error

Critic

b). Trust-Embedded Fairness-Aware DRL

Fig. 2. Overview of the proposed hierarchical trusted collaborator group formation and task allocation strategy for concurrent task completion under long-term fairness. It consists of two modules: (i) Hierarchical Task-Specific Trust Prediction via spatial-temporal GNNs, and (ii) Trust-Embedded Fairness-Aware DRL.

 K t̂ ⊤  Q t h Wy hy  W y y  √ at̂,t , y = ι d 

cluster centroid sx of a task set aggregates propagated data from collaborators is formulated as
l−1 hlx = UPD AGG({hl−1 (17) y ||ϖx→y , ∀y ∈ Y}) , l−1 denote and ϖx→y where || is the concatenation operator, hl−1 y the embeddings of the cluster centroid ny of a resource set and edge between sx and ny at layer l − 1, respectively. Besides, UPD(·) and AGG(·) denote the update function and aggregation function, respectively. We use weighted-sum aggregation to incorporate edge information and GRUs as the update function. Symmetrically, the resource-set centroid is updated as
l−1 hly = UPD AGG({hl−1 (18) x ||ϖx→y , ∀x ∈ X }) . L Note that hL x and hy represent the embeddings of sx and ny at the last layer L, respectively, and are expressed as ht̂x and ht̂y when static aggregation is performed at time t̂. To capture temporal variations, attention is applied to historical embeddings Hxt = [h1x , h2x , ..., htx ]⊤ and Hyt = [h1y , h2y , ..., hty ]⊤ yielding

hfinal = x

t X

V t̂ at̂,t x Wx hx ,

(19)

t̂=1

hfinal = y

t X

where ι is the softmax function for normalization, d is the dimension of each input embedding, WxQ , WxK , WyQ , and WyK are learnable parameter matrices. Algorithm 1: HTST-GNN for State Representation Input: Trust-guided bipartite graphs G(t) t+1 Output: Predicted trust matrices [Ŵ]t+1 X×Y and [Ŵ]|SM |×N // Dynamic Coarsening t̂ 1 foreach G ∈ G(t) do 2 Coarsen tasks and resources to obtain GCt̂ ; Store GC (t); // Coarse-Grained Trust Prediction 0 0 0 4 Initialize hx , hy , ϖx→y ; t̂ 5 foreach GC ∈ GC (t) do 6 Prune GCt̂ via (25); 7 Obtain ht̂x , ht̂y via (17)–(18); 3

t+1 Predict ŵx→y via (19)–(24); // Fine-Grained Trust Prediction 9 foreach (Cx , M(Cx )) do 10 Apply the same spatial-temporal prediction to sp ∈ Cx and n ∈ M(Cx ); t+1 11 Obtain ŵp→n ; 8

12

V t̂ at̂,t y Wy hy ,

(20)

t̂=1 V where Wm and WjV are learnable parameter matrices, at̂,t x and t̂,t ay are normalized attention coefficients, which measure the relative importance of embeddings from each time slot t̂ to the target time slot t as follows 
 K t̂ ⊤  Q t W h Wx hx  x x  √ at̂,t (21) , x = ι d

(22)

Store the coarse- and fine-grained trust matrices;

3) Prediction and Training: The final embeddings are mapped by an Multi-Layer Perception (MLP) to obtain the edge embedding, given by t+1 final ϖ b x→y = MLP(hfinal x ||hy ).

(23)

The corresponding trust value is subsequently derived by t+1 transforming ϖ b x→y into scalar representation, formulated as t+1 t+1 ŵx→y = κ(Wp · ϖ b x→y + bp ),

(24)

where κ is a sigmoid function that maps the trust values to the range [0, 1], Wp and bp are learnable parameter matrices.

8

To make the trust prediction process task-specific, training is restricted to graph knowledge from similar tasks, thus reducing excessive complexity influenced by the size and interdependent diversity of nodes and edges in trust-guided bipartite graphs. Thus, a sub bipartite graph of GCt̂ relevant to the new subtask st+1 is obtained by pruning the coarsel grained task sets and edges into two subsets, denoted as t̂ e Λt̂,t+1 ≥ ν} and EeCt̂ →C = {et̂x→y |∀x ∈ CeM = {Cxt̂ |∀x ∈ X, lx M N e ⊆ X indicates the pruned e ∀y ∈ Y, Λt̂,t+1 ≥ ν}, where X X, lx subset of coarse-grained task sets, ν represents a similarity threshold, and Λt̂,t+1 is the similarity coefficient between lx new subtask st+1 and previous cluster centroid st̂x , which is l calculated based on Cosine similarity, given by
⊤ h0l (t + 1) · h0x (t̂) t̂,t+1 Λlx = 0 , (25) ∥hl (t + 1)∥2 · ∥h0x (t̂)∥2 where ∥ · ∥2 indicates the L2 norm of a vector. The GNN parameters Ψ are optimized using the crossentropy loss, which is denoted as t+1 t+1 Ψ∗ = arg min L(ŵx→y , wx→y ), Ψ

(26)

t+1 indicates the ground truth, and the Adam optiwhere wx→y mizer is utilized. For highly similar tasks, learned parameters are reused directly, otherwise fine-tuning is performed. Remark 2: After coarse-grained trust prediction, the matched resource sets M(Cx ) form candidate collaborator pools for each task set Cx , The same spatial-temporal aggregation and task-specific training are then applied to subtasks sp ∈ Cx and collaborators n̂ ∈ M(Cx ), yielding fine-grained t+1 . The procedure of HTSTtrust predictions with value ŵp→n GNN is summarized in Algorithm 1.

B. Trust-Embedded Fairness-Aware DRL We solve P in (16) through hierarchical DRL [17], [27], progressively reducing the task-collaborator matching space. A coarse-grained policy first matches task and resource sets, after which a fine-grained policy performs subtask-collaborator matching within the selected sets. Stage I (Optimization of the Coarse-Grained Task SetResource Set Matching Policy): The coarse-grained matching ∗ policy πH is learned after dynamic coarsening of tasks and resources, formulated as ∗ P 1 : πH = arg max πH

s.t.,

Y X

X X

U (Qx )

(27)

x=1

xyx (t) ≥ 1, ∀Cx ∈ CM , t ∈ T ,

(27a)

xyx (t) ≥ 1, ∀Cy ∈ CN , t ∈ T ,

(27b)

y=1 X X x=1

|SMx | ≤

X

X

|Vn̂ | , ∀Cx ∈ CM ,

(27c)

Cy ∈M(Cx ) n̂∈Cy

PT where Qx = limT →∞ T1 t=1 Qx (t) denotes the longterm average utility of task set Cx , with Qx (t) =

up (t) sp ∈Cx ϱ+rαp (t) aggregating subtask-level value up (t) and risk rαp (t). Here, xyx (t) indicates the matching decision 1 |SMx |

P

between Cx and Cy . Constraints (27a)-(27c) permit many-tomany set matching while ensuring that the subtasks in each task set do not exceed the available VMs of its matched resource sets M(Cx ). Stage II (Optimization of the Fine-Grained SubtaskCollaborator Matching Policy Within Matched Task-Resource Sets): Conditioned on the coarse-grained matching policy ∗ ∗ πH , the fine-grained policy πL optimizes subtask-collaborator matching within selected sets, formulated as ∗ P 2 : πL = arg max πL

X |S Mx | X X

U (Qp )

(28)

x=1 p=1

s.t., (16a) − (16d), P u (t) T where Qp = limT →∞ T1 t=1 ϱ+rpα (t) denotes the long-term p utility of subtask sp . 1) Stage I–Design and Learning of Coarse-Grained Level Matching Policy: The collaborative system and task sets serve as environment and learning agents, respectively, optimizing ∗ to maximize the task set rewards in an infinite-horizon πH discounted MDP. The three key components of MDP in P 1 are elaborated as follows: a). State: The coarse-grained state is the predicted taskH specific trust matrix, defined as sH = [sH t 1 (t), . . . , sX (t)], t t H where sx (t) = [ŵx→1 , . . . , ŵx→Y ] denotes the predicted trust values of task set Cx over all resource sets at time t. H = [aH b). Action: The action aH t 1 (t), ..., aX (t)] represents task-set/resource-set matching decisions, where aH x (t) = [x1x (t), ..., xYx (t)]. c). Rewards: Because long-term utility is unavailable online, the instantaneous reward rxt = Qx (t) is weighted by the derivative the α-fair utility in (15) using the running average Pof t h̄tx = 1t t̂=1 rxt̂ . The adjusted reward is then given by rext = rxt U ′ (h̄tx ),

(29)

where U ′ (·) denotes the derivative of the fairness utility, assigning higher weights to tasks with lower long-term utility. At time t, task sets observe the state sH t and select an action aH following the policy π(a|s), which is represented by t Artificial Neural Networks (ANNs) πϑH , where ϑH indicates the policy parameter associated with ANNs. The following theorem establishes the stationary-point property of the resulting policy. Theorem 1 (Policy Parameter ϑ∗H is the Stationary Point of the α-Fair Utility Optimization). By following the optimal policy πϑ∗H , the gradient (or derivative) of thePα-fair utility optimization problem equals zero, i.e., X ∇ϑH [ x=1 U (Qx )]|ϑH =ϑ∗H = 0. Proof: Detailed derivations are given in Appendix A. Based on Theorem 1, we propose a trust-embedded fairnessaware DRL algorithm with actor-critic structure to solve the α-fair utility optimization in (27), in which the actor neural network selects actions according to the policy, while the critic neural network evaluates actions and guides policy updates.

9

a). Actor Neural Network: Employing the gradient Ppolicy X method, the policy gradient of the objective x=1 U (Qx ) for P 1 is given by "X # X ∇ϑ H U (Qx ) = x=1

h i EπϑH ÂπϑH (s, a)∇ϑH ln πϑH (a|s) ,

(30)

where ÂπϑH (s, a) = Q̂πϑH (s, a) − V̂πϑH (s) denotes the advantage function that quantifies an action deviation from the expected state value. Here, " T X XX t Q̂πϑH (s, a) = lim EπϑH rex − ϱ̂πϑH T →∞

t=1 x=1

# s0 =s,a0 =a

" T X XX t V̂πϑH (s) = lim EπϑH rex − ϱ̂πϑH t=1 x=1

# s0 =s

represent the relative state-value and action-value functions, both centered by the average reward ϱ̂πϑH = PT PX limT →∞ T1 t=1 x=1 rext . Then, the policy gradient update for ϑH is given by # "X X ϑH ← ϑH + ηϑH · ∇ϑH (31) U (Qx ) , x=1

where ηϑH > 0 is the learning rate for the policy update. b). Critic Neural Network: The critic estimates the relative state-value function V̂πϑH (s) to evaluate the policy πϑH and to guide actor updates. The critic approximates V̂πϑH (s) with V̂ωH (s) and are optimized by minimizing the Mean Squared Error (MSE) loss, formulated as " #2  X  X  L (ωH ) = E rext + γ0 V̂ωH (st+1 ) − V̂ωH (st ) ,   x=1

(32) where γ0 is the discount factor. The parameters ωH are iteratively updated as ωH ← ωH +ηωH · ∇ωH L (ωH ) ,

(33)

where ηωH > 0 is the learning rate for ωH . Algorithm 2: Trust-Embedded Fairness-Aware DRL L Input: Initial states sH t , st , learning rates, γ0 Output: Coarse-grained policy πϑ∗ and fine-grained policy πϑ∗ H L 1 Initialize actor and critic parameters ϑH , ωH , ϑL , ωL 2 foreach I = 1 : T /∆T do 3 foreach t = 1 : ∆T do H t 4 Sample aH ex via Eq. (29); update t ; obtain st+1 ; compute r ϑH , ωH via Eqs. (31)–(33); 5 6 7

Cx

}|

z

{

  L L sL t = (s1,x (t), . . . , s|SMx |,x (t)), ∀Cx ∈ CM ,

and T →∞

2) Stage II–Design and Learning of Fine-Grained Level Matching Policy Within Matched Task-Resource Sets: Under the converged coarse-grained level matching policy πϑ∗H , which determines the candidate resource sets for each task ∗ set, the optimal matching results aH between task sets and t resource sets are obtained. Based on these matched sets, the fine-grained policy πϑ∗L further optimizes the matching between individual subtasks and collaborators to solve P 2 under long-term fairness. a). State: Based on the trust prediction results between subtasks and collaborators within matched sets, the state is defined as

Extract (Cx , M(Cx )), ∀x ∈ X ; foreach t = 1 : ∆T do L t Sample aL ep,x via Eq. (34); update t ; obtain st+1 ; compute r ϑL , ωL following the Stage-I actor–critic updates;

The optimal matching policy between task sets and resource sets πϑ∗H is obtained upon the objective function P 1 convergence after multiple iterations I, where each iteration runs for ∆T time steps and the learning procedure is summarized in lines 3-5 of Algorithm 2.

where the subvector is given by sL = p,x (t) t t [ŵp→1 , ..., ŵp→|M(C ] and |M(C )| denotes the number of x x )| collaborators in M(Cx ). b). Action: Each subtask in Cx is assigned to one collaborator from M(Cx ), where the action space is restricted to matched sets, reducing the search space from O(N |SM | ) to O(N |M(Cx )| ), |M(Cx )| ≪ |SM |. The fine-grained level action set is given by Cx

z

}|

{

 L  L aL t = (a1,x (t), . . . , a|SMx |,x (t)), ∀Cx ∈ CM ,

where the matching action for sp ∈ Cx follows aL p,x (t) = |M(Cx )| 1 [xp,x (t), ..., xp,x (t)]. t = c). Rewards: Similar to Stage I, the original reward rp,x up (t) is adjusted under long-term fairness, yielding ϱ+rα (t) p

t t rep,x = rp,x U ′ (h̄tp,x ),

(34)

Pt 1

t̂ , ∀t̂ ∈ {1, 2, ..., t} represents the where h̄tp,x = t t̂=1 rp,x average historical reward for subtask sp . Based on the above MDP, the fine-grained policy πϑL follows the same actor-critic learning procedure as Stage I, H t ex , ϑH , ωH ) replaced by fine-grained counterwith (sH t , at , r L t L parts (st , at , rep,x , ϑL , ωL ). Actor and critic updates therefore follow (30)–(33) within the matched task-resource sets. The overall learning procedure of the fine-grained level matching policy πϑL is stated in lines 6-7 of Algorithm 2.

C. Computational Complexity Analysis The dynamic coarsening process incurs O(|SM |X|F |I + |N |Y |F |I), where |F| and I denote the feature dimension and the number of K-means iterations, respectively. Since X ≪ |SM | and Y ≪ |N |, this introduces only a lower-order cost. The coarse-grained complexity is  L|ECM →CN |d + t(X + Y )d2 {z }  | Trust Prediction      Lpol   val X (i) (i+1) L X O , (j) (j+1)  + Tcoarse  npol npol + nval nval    i=0 j=0   | {z } 

Matching

where the two terms correspond to spatial-temporal trust prediction [24], [25] and actor-critic matching [27], respectively.

10

At the fine-grained level, computation is restricted to the matched task-resource sets, yielding 

 XX L |Ep∈Cx →n∈Cy |d + t(|SM | + |N |)d2   x {z } |   Trust Prediction      Lpol L val O X (i) (i+1) X (j) (j+1)  ,  + Tfine    n n + n n   pol pol val val   i=0 j=0   {z } | Matching

PX

where x |Ep∈Cx →n∈Cy | denotes the number of edges within the matched sets and Tcoarse + Tfine = T . Hence, the hierarchical design limits coarse-grained computation to the coarsened graph and fine-grained optimization to matched task-resource sets, reducing the overall matching and graphprocessing burden. IV. P ERFORMANCE E VALUATION This section first presents the simulation setup and several comparison strategies, followed by evaluations addressing three key questions. Q1: How quickly does the proposed strategy converge compared with existing task offloading strategies? Q2: How robust is the proposed strategy across different problem sizes, fairness objectives, and key parameter settings? Q3: How resilient is the proposed strategy to different attack scenarios compared with existing strategies? A. Simulation Setup We simulate a 3D space of 1000×1000×100 m, consisting of multiple UAVs and UGVs that are randomly distributed. 1) Parameter Settings of Tasks and Resources: We consider three task graph types (Bull, Star, and Tadpole) of UAVs [34] as shown in Fig. 3, where interdependent subtasks reii′ ∈ [0.1, 0.3] [11]. Apart from quire contact durations wm graph topologies, each subtask possesses individual commax pletion goals, i.e., tmax im ∈ [0.2, 0.9] s, eim ∈ [7, 14] kJ, max θim = {0.2, 0.5, 0.8}. New tasks are generated every 20 time slots, each lasting 0.05 s. Besides, the edge weight of the resource graph follows wnn′ ∈ [0.05, 0.06] in small problem sizes and wnn′ ∈ [0.01, 0.02] in large problem sizes [11].

Type 1: Bull

Type 2: Star

Type 3: Tadpole

Fig. 3. Illustration of task graph types used in the simulations.

2) Parameter Settings of Attacks: The simulations include ground Eves and malicious collaborators, accounting for 10% and 20% of the UGVs, respectively, following [12]. On-Off attackers alternate between legitimate and malicious behaviors in 20-time-slot cycles [12]. All proportions are rounded up when necessary. The HTST-GNN uses two spatial aggregation layers with a learning rate of 0.001, structural dropout of 0, and temporal

dropout of 0.5. The actor and critic each use 250 hidden units with learning rates of 0.001 and 0.01, respectively; γ0 = 0.9, and Adam is used for optimization. These hyperparameters are empirically tuned with initial values guided by [25]. Other simulation parameters follow [33], [35] and are listed in Table II. All weighting parameters are set equally, i.e., ς1−6 = ξ1−3 = 31 and ϵ1,2 = ζ1,2 = 0.5. TABLE II M AJOR S IMULATION PARAMETERS Parameters Subtask data size Dim Subtask processing density ρim VM CPU clock frequency fjn jam Jamming signal transmit power pn A2G channel bandwidth W Transmission power pm Reference channel gain g1 path loss exponent η Maximum estimation error ∆g1,2 Noise power σ 2 Data exchange time threshold µ

Value [200, 1000] Kb {500,600,700,800} cycles/bit {0.5, 0.8, 1} GHz [50, 200] mW [6, 8] MHz {100,150,200} mW -30 dB 3 10−8 -100 dBm [0.9, 1)

B. Comparison Strategies We compare the proposed strategy with representative baselines for dynamic collaborator selection. Each baseline removes or simplifies one or more core components to isolate their contributions. 1) GDTrust [12]: A strategy that selects collaborators according to weighted trust scores updated upon task completion. 2) TrustGNN [24]: A GNN-based collaborator selection strategy using the same spatial architecture as ours but without temporal feature aggregation. 3) SARSA [16]: An RL strategy that maximizes long-term reward without considering trust and fairness. 4) FairPG [32]: A fairness-aware policy-gradient strategy using Monte Carlo sampling. C. Convergence Analysis (Q1) Fig. 4 evaluates convergence over 30,000 training steps with six task requestors, comprising two Bull, two Star, and two Tadpole tasks. For = 1, (16) reduces to proportional Pα M fairness optimization, m=1 log(Qm ). As shown in Fig. 4(a), the proposed strategy converges within approximately 10,000 steps and stabilizes around −0.2. TrustGNN and GDTrust converge more slowly due to limited temporal trust modeling, while SARSA performs poorly without fairness consideration. FairPG also converges more slowly because of its Monte Carlo-based policy-gradient estimation. We further evaluate the effectiveness of the proposed strategy to optimize other PM fairness objectives. For α = 2, the objective becomes m=1 −1/Qm , which penalizes lowutility tasks more heavily. Fig. 4(b) exhibits a similar trend: the proposed strategy achieves the fastest and most stable convergence, whereas FairPG converges more slowly and the remaining baselines achieve lower utility. Fig. 4(c) further shows convergence across different task graph types. Bull tasks converge faster because of higher

11

(a)

(b)

(c)

Fig. 4. Convergence comparison: (a) proportional fairness utility; (b) α-fairness utility; (c) average task utility across task graph types.

Bull+Star+Tadpole

(a) Bull+Star+Tadpole

(c)

3*Bull+3*Star+3*Tadpole

(b) 3*Bull+3*Star+3*Tadpole

(d)

Fig. 5. Fairness utility across problem sizes: (a)–(b) proportional fairness; (c)–(d) α-fairness under small and large settings.

connectivity, whereas Star and Tadpole tasks initially exhibit lower or more fluctuating utility; nevertheless, their utilities gradually converge under the fairness-aware policy. D. Robustness and Parameter Sensitivity Analysis (Q2) We evaluate robustness across problem sizes, similarity thresholds, and fairness objectives. Task completion goals are randomly generated, with results averaged over 10,000 and 15,000 steps for proportional and α-fairness utilities, respectively. Fig. 5 shows that the proposed strategy consistently achieves the highest fairness utility across both small and large problem sizes and under both fairness objectives. TrustGNN, GDTrust, and SARSA perform worse because they do not jointly account for long-term fairness, dynamic trust, and hierarchical matching. Although FairPG explicitly optimizes fairness, its Monte Carlo-based policy gradient converges more slowly.

These results demonstrate the scalability and robustness of the proposed hierarchical framework. Fig. 6 evaluates the impact of the similarity threshold ν under different fairness objectives and problem sizes. Thresholds around 0.4–0.6 consistently achieve strong performance: smaller values retain more unrelated graph information and increase training overhead, whereas larger values prune relevant task relationships and reduce utility. We therefore set ν = 0.5 to balance prediction accuracy and computational efficiency. E. Attack Resistance Analysis (Q3) We evaluate blackhole, on-off, and eavesdropping attacks using 60 UGVs, 84 VMs, and 73 edges under the 3*Bull+3*Star+3*Tadpole setting. Fairness utilities are averaged over 10,000 and 15,000 steps for proportional fairness (PF) utility and α-fairness (AF) utility, respectively. Attack resistance is measured by the fraction of malicious UGVs

12

(a)

(b)

Fig. 6. Impact of similarity threshold ν under different problem sizes: (a) proportional fairness utility; (b) α-fairness utility.

Blackhole Attack

(a)

On-Off Attack

(b)

Eavesdropping Attack

(c)

Fig. 7. Attack robustness under (a) blackhole, (b) on-off, and (c) eavesdropping attacks. In each subfigure, bars represent the proportional and α-fairness utility values achieved by different strategies, while lines indicate average attack resistance and secrecy rates.

successfully avoided, while secrecy rate quantifies secure taskdata transmission in the presence of Eves. For blackhole and on-off attacks, the malicious-UGV ratio is increased to 50%. As shown in Figs. 7(a) and 7(b), onoff attacks are more disruptive because intermittent malicious behavior reduces detectability and allows attackers to maintain deceptive trust values. Nevertheless, the proposed strategy degrades more gracefully than TrustGNN and GDTrust and maintains approximately 93% attack resistance even with 50% on-off attackers. Fig. 7(c) shows that secrecy rates decrease as the number of ground Eves increases from 3 to 12. The proposed strategy nevertheless maintains higher fairness utility and stronger resilience than the baselines because its trust-aware adaptive policy reduces the impact of unreliable collaborators and compromised links. V. C ONCLUSION This paper has proposed a fairness-aware concurrent task orchestration strategy for trusted collaborator group formation and task allocation in resource-constrained collaborative systems. A unified task utility model captures the value–risk tradeoff of task completion, based on which concurrent task orchestration is formulated as a long-term average utility maximization problem under α-fairness. To solve this problem, a hierarchical coarse-to-fine matching framework integrates task-specific trust prediction via spatial-temporal GNNs with

fairness-aware DRL. The predicted trust values provide abstracted state representations for matching decisions, while fairness-aware rewards balance long-term task utilities under resource contention. Simulation results demonstrate improved task completion performance over representative baselines and consistent robustness under varying problem sizes, fairness objectives, and attack conditions. In particular, the proposed strategy improves concurrent task completion performance by 22% over representative baselines and maintains an average attack resistance rate of approximately 93% even when 50% of UGVs launch on-off attacks.

R EFERENCES [1] Y. Fu, P. Qin, and C. Jiang, “Edge AI inference in 6G mobile networks: From communication-efficient techniques to task-oriented optimization,” IEEE Commun. Surv. Tutor., vol. 28, pp. 6174–6210, 2026. [2] W. Zhao, Y. Yu, B. Mao, and N. Kato, “A survey on computing power networks: Architecture, resource allocation, and AI services enablement,” IEEE Trans. Netw. Sci. Eng., vol. 13, pp. 6225–6242, 2026. [3] X. Hou, J. Wang, J. Du, C. Jiang, and Y. Ren, “Distributed machine learning for autonomous agent swarm: A survey,” IEEE Commun. Surv. Tutor., vol. 28, pp. 1597–1636, 2026. [4] J. Pei, M. Dai, A. Al-Dulaimi, S. Al-Rubaye, and S. Mumtaz, “Taskoriented communication and optimization framework for 6G nonterrestrial networks: Challenges and solutions,” IEEE Commun. Mag., vol. 63, no. 11, pp. 138–144, 2025. [5] X. Liu, W. Li, B. Cao, S. Wang, and Z. Lyu, “Large-scale multiobjective vehicle task offloading optimization based on cloud-edge-end collaboration for 6G enabled transport systems,” IEEE Trans. Intell. Transp. Syst., vol. 26, no. 10, pp. 18 170–18 179, 2025.

13

[6] M. D. Khattak, M. A. Qasmi, Y. Rehan, A. A. Nasir, H. Jung, and S. A. Hassan, “Security-aware semantic communication: Threat modeling and adversarial-resilient frameworks for 6G networks,” IEEE Network, pp. 1–9, 2026. [7] M. Zhao, Z. Wang, K. Guo, R. Zhang, and T. Q. Quek, “Against mobile collusive eavesdroppers: Cooperative secure transmission and computation in UAV-assisted MEC networks,” IEEE Trans. Mob. Comput., vol. 24, no. 6, pp. 5280–5297, 2025. [8] Z. He, Y. Sun, Z. Ma, B. Wang, H. Xu, and Y. Miao, “HADES: Heterogeneity-aware dependent task offloading in collaborative edge networks,” IEEE Trans. Mob. Comput., vol. 25, no. 10, pp. 15 879– 15 896, 2026. [9] T. Du, X. Gui, and T. Sheng, “Multiagent deep reinforcement learningbased hierarchical scheduling in heterogeneous UAV-enabled vehicular networks,” IEEE Internet Things J., vol. 12, no. 24, pp. 54 938–54 954, 2025. [10] B. Li, X. Wang, and F. Fang, “Maximizing the value of service provisioning in multi-user ISAC systems through fairness guaranteed collaborative resource allocation,” IEEE J. Sel. Areas Commun., vol. 42, no. 9, pp. 2243–2258, 2024. [11] B. Guo, M. Liwang, X. Xia, L. Li, Z. Jiao, S. Hosseinalipour, and X. Wang, “Seamless graph task scheduling over dynamic vehicular clouds: A hybrid methodology for integrating pilot and instantaneous decisions,” IEEE Trans. Serv. Comput., vol. 18, no. 3, pp. 1753–1768, 2025. [12] J. Chen, X. Wang, and X. Shen, “Goal-driven trusted collaborator selection and task offloading in dynamic collaborative systems,” IEEE Internet Things J., vol. 12, no. 7, pp. 8537–8551, 2025. [13] I. I. Ioannou, C. Christophorou, and V. Vassiliou, “AI/ML for D2D communication in 5G/6G networks and beyond: Concept, applications, challenges, and future directions,” IEEE Open J. Commun. Soc., vol. 7, pp. 5283–5349, 2026. [14] X. Chen, Y. Bi, J. Zhang, X. Yuan, D. Niyato, L. Zhao, and X. Wang, “Task offloading and resource optimization based on dependency-aware graph and collaborative deep reinforcement learning in mobile edge computing,” IEEE Trans. Mob. Comput., vol. 25, no. 7, pp. 10 998– 11 015, 2026. [15] M. Min, J. Duan, M. Liu, N. Wang, P. Zhao, H. Zhang, and Z. Han, “Task offloading with differential privacy in multi-access edge computing: An A3C-based approach,” IEEE Trans. Cogn. Commun. Netw., vol. 12, pp. 5676–5689, 2026. [16] T. Alfakih, M. M. Hassan, A. Gumaei, C. Savaglio, and G. Fortino, “Task offloading and resource allocation for mobile edge computing by deep reinforcement learning based on SARSA,” IEEE Access, vol. 8, pp. 54 074–54 084, 2020. [17] H. Jin, X. Zhang, W. Yuan, J. Wang, J. Wu, X. Wang, R. Tafazolli, M.-S. Alouini, S. Sun, S. Yu, D. I. Kim, A. Jamalipour, and X. Shen, “Agentic low-altitude wireless networks: Fundamentals, design, and future directions,” IEEE Trans. Cogn. Commun. Netw., pp. 1–1, 2026. [18] Q. Xu, L. Zhang, Y. Liu, and Z. Li, “Enhancing trust management system for connected autonomous vehicles using machine learning methods: A survey,” IEEE Trans. Intell. Transp. Syst., vol. 27, no. 4, pp. 3862–3893, 2026. [19] S. Wang, T. Qin, T. Chen, W. Guo, Y. Hu, and H. Sun, “A high-reliability small-area task offloading mechanism with trust evaluation and fuzzy logic in power IoTs,” IEEE Trans. Mob. Comput., vol. 24, no. 4, pp. 2935–2948, 2025. [20] J. Wang, Z. Li, H. Liu, T. Qiu, and H. Luo, “A trust-based computation offloading framework in mobile cloud-edge computing networks,” IEEE Trans. Mob. Comput., pp. 1–15, 2025. [21] J. Chen, X. Wang, and X. Shen, “RTE: Rapid and reliable trust evaluation for collaborator selection and time-sensitive task handling in Internet of Vehicles,” IEEE Internet Things J., vol. 11, no. 7, pp. 12 278–12 291, 2023. [22] J. Green, X. Wang, J. Chen, and J. Burkell, “Decode and combine: Trust permeability via task specifics fusion for trusted collaborator selection,” IEEE Trans. Comput. Soc. Syst., pp. 1–16, 2026. [23] B. Zhu, J. Wang, D. Niyato, and X. Wang, “Trust semantics distillation for collaborator selection via memory-augmented Agentic Al,” IEEE Netw., vol. 40, no. 3, pp. 168–175, 2026. [24] C. Huo, D. He, C. Liang, D. Jin, T. Qiu, and L. Wu, “TrustGNN: Graph neural network-based trust evaluation via learnable propagative and composable nature,” IEEE Trans. Neural Netw. Learn. Syst., vol. 35, no. 10, pp. 14 205–14 217, 2024. [25] J. Wang, Z. Yan, J. Lan, E. Bertino, and W. Pedrycz, “TrustGuard: GNNbased robust and explainable trust evaluation with dynamicity support,”

IEEE Trans. Dependable Secure Comput., vol. 21, no. 5, pp. 4433–4450, 2024. [26] Y. Diao, R. Ding, Z. Zeng, F. Zhou, and Q. Wu, “Dynamic spectrum aggregation and resource allocation for embodied-enhanced cognitive UAV networks using hybrid action space DRL,” IEEE Trans. Cogn. Commun. Netw., vol. 12, pp. 9806–9819, 2026. [27] J. Mei, X. Wang, K. Zheng, G. Boudreau, A. B. Sediq, and H. AbouZeid, “Intelligent radio access network slicing for service provisioning in 6G: A hierarchical deep reinforcement learning approach,” IEEE Trans. Commun., vol. 69, no. 9, pp. 6063–6078, 2021. [28] H. Guo, X. Chen, X. Zhou, and J. Liu, “Trusted and efficient task offloading in vehicular edge computing networks,” IEEE Trans. Cogn. Commun. Netw., vol. 10, no. 6, pp. 2370–2382, 2024. [29] K. Ahmad Awan, I. Ud Din, A. Almogren, Z. Han, and M. Guizani, “TrustAware-GNN: Graph-neural-network-based trust management for IoT anomaly detection,” IEEE Internet of Things J., vol. 12, no. 18, pp. 37 670–37 681, 2025. [30] N. Shi, L. Liu, Y. Zhou, H. Yu, Y. Wu, J. Yang, and J. Shi, “Long-term fairness from real-time decisions: Reward adaptive multi-agent DRL for wireless communication with imperfect CSI,” IEEE Trans. Cogn. Commun. Netw., vol. 12, pp. 8077–8092, 2026. [31] P. S. Eftetahi, L. Cai, and A. Sepahi, “Fair beam scheduling in LEO satellite networks with reinforcement learning,” IEEE Trans. Cogn. Commun. Netw., vol. 12, pp. 5438–5450, 2026. [32] W. Liu, Z. Chen, J. Ye, and X. Ge, “User scheduling algorithm based on parallel Monte Carlo policy gradient sampling in downlink massive MIMO communication systems,” IEEE Wirel. Commun. Lett., pp. 1–1, 2025. [33] J. Yao, C. Tang, J. Xu, Y. Fang, G. Han, and T. Q. S. Quek, “Delay-aware secure offloading for RSMA-assisted mobile edge computing networks,” IEEE Trans. Wirel. Commun., vol. 25, pp. 19 260–19 275, 2026. [34] M. Liwang, B. Guo, Z. Ma, Y. Su, J. Jin, S. Hosseinalipour, X. Wang, and H. Dai, “Unleashing the potential of stage-wise decision-making in scheduling of graph-structured tasks over mobile vehicular clouds,” IEEE Commun. Mag., vol. 63, no. 2, pp. 144–150, 2025. [35] B. Zhu and X. Wang, “Networked physical computing: A new paradigm for effective task completion via hypergraph aided trusted task-resource matching,” IEEE Trans. Netw. Sci. Eng., vol. 13, pp. 1226–1242, 2026. [36] Y. Zeng, Z. Lu, X. Zhao, Z. Xiao, S. Ni, Z. Han, and K. Li, “GNSS jamming and spoofing threats in UAV navigation: Countermeasure status and challenges,” IEEE Commun. Surv. Tutor., vol. 28, pp. 5909–5948, 2026. [37] Y. Ma, L. Liu, Z. Liu, F. Li, Q. Xie, K. Chen, C. Lv, Y. He, and F. Li, “A survey of DDoS attack and defense technologies in multiaccess edge computing,” IEEE Internet Things J., vol. 12, no. 2, pp. 1428–1452, 2025. [38] H. Fang, X. Wang, N. Al-Dhahir, and R. Schober, “Joint design of multidimensional multiple access and lightweight continuous authentication in zero-trust environments,” in Proc. IEEE Global Communications Conference (GLOBECOM), 2023, pp. 3366–3371. [39] J. Chen and X. Wang, “Task-specific trust prediction with GNN for minimized risk of task completion in dynamic collaborative systems,” in Proc. IEEE Int. Conf. Commun. Workshops (ICC Wkshps), 2025, pp. 1–6. [40] H. Hao, C. Xu, W. Zhang, S. Yang, and G.-M. Muntean, “Taskdriven priority-aware computation offloading using deep reinforcement learning,” IEEE Trans. Wirel. Commun., vol. 24, no. 10, pp. 8114–8128, 2025.

Related documents

• Concurrent Task Orchestration: Hierarchical Trusted Collaborator Group Formation for Constrained Resource Allocation#1455776
• Group Decision-Making in Computer-Supported Cooperative Work Environments#212547
• UAV-SwarmAgent: Scalable Multi-UAV Reconnaissance and Task Allocation via Code Generation and Vision-Language Reasoning#1447926
• The interdisciplinary study of coordination#6617
• The Cost of Coordination: Why Multi-Agent LLMs Explore More But Discover Less#368869