Dynamic Multi-Robot Task Allocation for Human-in-the-Loop Space Exploration: Knowledge Graph-Guided CBBA with LLM-Assisted Fault Analysis

Abstract

In dynamic and extreme space environments, current multi-robot systems inevitably encounter failures during autonomous task execution. Addressing these failures requires human-in-the-loop collaboration with astronauts, who first conduct fault analysis and then perform dynamic multi-robot task allocation (MRTA), a process critical for achieving mission objectives. This paper proposes a Knowledge Graph-guided Consensus-Based Bundle Algorithm (KG-CBBA) that integrates astronaut fault analysis generated by large language models (LLMs) into the fault recovery process for space exploration. Firstly, a knowledge graph (KG) is constructed to encode objective constraints and semantic triples between tasks and robots, enabling a unified representation of task feasibility and utility. Secondly, a semantic-enhanced utility allocation mechanism is designed to ensure consistent, feasible, and efficient task sequences under static allocation. When dynamic tasks arrive, KG-CBBA resolves conflicts and inserts new tasks while preserving the stability of existing task sequences. Numerical simulations validate the feasibility of KG-CBBA and demonstrate its superior performance compared with consensus-based bundle algorithm (CBBA), particle swarm optimization (PSO), and greedy baselines. In addition, a user study involving 96 participants shows that KG-CBBA, when integrated with LLMs, enhances collaborative fault recovery. Overall, KG-CBBA provides an effective solution for dynamic MRTA in space exploration and supports human-in-the-loop collaboration.

1. Introduction

As space exploration continues to advance, establishing space bases in polar regions has become a key objective [1,2]. Single-robot systems are increasingly inadequate for meeting this demand [3], turning multi-robot collaboration into an essential trend [4,5,6]. Confronted with high-risk environmental factors and uncertain payload conditions in space environments [7], current autonomous robots are prone to failures, such as wheel slippage caused by geological characteristics [8] or positioning errors resulting from steering motor malfunctions [9]. Therefore, efficient and reliable fault recovery within multi-robot systems remains a central challenge in space exploration.

Similar challenges can be formulated as a dynamic MRTA problem [10,11], which is known to be NP-hard. Due to the unstructured nature of space environments, end-to-end algorithms often fail to capture the uncertainties inherent in dynamic task allocation [12]. One solution involves human supervisors performing contingency-based fault analysis and rapidly updating tasks through heuristic assignment strategies [13]. In our prior work [14], we proposed knowledge-enhanced LLMs for space exploration that assist astronauts in fault analysis. Leveraging this capability, the fault analysis results generated by LLMs can be integrated into the fault recovery process. Thus, new tasks can be generated through astronaut-supported fault analysis, after which dynamic MRTA can be autonomously executed to address the challenges in space environments.

Dynamic MRTA frameworks are generally categorized into two types: centralized and distributed [15]. Centralized approaches rely on a single central node that performs the entire optimization process and subsequently distributes decisions to individual units [16]. Centralized algorithms such as PSO [17] and ant colony optimization (ACO) [18] address dynamic MRTA problems from a global perspective, and they are capable of producing near-optimal solutions. However, as the problem scale increases, the data volume and computational load handled by the central node grow substantially, thereby limiting the performance of centralized methods in dynamic MRTA settings [19].

In contrast, distributed algorithms enable robots to make autonomous decisions under task constraints, achieving global coordination through iterative optimization [20]. CBBA, as a robust and scalable distributed algorithm, is particularly well suited for dynamic MRTA problems [21]. Bi et al. [22] proposed an improved CBBA capable of rapidly responding to unmanned aerial vehicle (UAV) failures in dynamic multi-UAV allocation. Zhang et al. [23] introduced a task allocation architecture that combines CBBA with the gray wolf optimizer (GWO), where GWO determines the optimal architecture and CBBA performs task allocation to address dynamic multi-UAV scheduling. These studies show that CBBA is suitable for solving dynamic MRTA problems. However, it remains necessary to explore how to better adapt CBBA to fault recovery processes that integrate LLMs.

Due to communication delays in space exploration [24], fault analysis is typically performed by astronauts, who are selected based on education, unique skills, and health [25], rather than by specialized experts. LLMs can support astronauts in conducting fault analysis [14], and when integrated with KGs, they further enhance the interpretation and utilization of semantic relationships [26]. This suggests that KGs may be incorporated into dynamic MRTA. For instance, Nasar et al. [27] combined case-based reasoning (CBR) with KGs for search-and-rescue planning to improve decision making, while Lee et al. [28] proposed a distributed dynamic framework that integrates KGs with hardware control methods for multi-robot collaboration. However, the integration of KGs and LLMs for dynamic MRTA has been seldom explored. To address such faults in space environments, it is essential to develop a dynamic MRTA framework capable of responding to failures and performing fault recovery through human-in-the-loop collaboration.

Based on the above analysis, this paper proposes a KG-CBBA method for dynamic MRTA to enable fault recovery in space exploration. The main contributions are as follows:

• KG-based modeling framework for space missions. A KG is developed to incorporate task attributes, robot capabilities, and their relationships. This framework uniformly encodes semantic information, including spatiotemporal constraints, capability matching, and resource consumption. On this basis, task allocation objectives tailored to the characteristics of space missions are defined, providing a systematic modeling foundation for task allocation algorithms.
• Multi-robot allocation mechanisms for static and dynamic scenarios. Addressing the coexistence of static and dynamic characteristics in MRTA for space exploration [29], KG-CBBA improves the traditional CBBA framework by implementing both static and dynamic allocation methods. It addresses efficiency and distributed consistency challenges under dynamically arriving tasks, while optimizing utility and ensuring task feasibility during the initial allocation phase.
• Dynamic task integration for LLM-assisted fault analysis. In scenarios where LLMs assist astronauts in fault analysis, KG-CBBA transforms newly added or modified tasks into dynamic subgraph updates. Through incremental processing, the framework enables distributed bidding, allocation, and conflict resolution for these tasks, thereby facilitating multi-robot fault recovery driven by LLMs.

The remainder of this paper is organized as follows. Section 2 introduces the space missions and presents the KG framework along with the allocation objectives. Section 3 proposes the KG-CBBA method for static and dynamic MRTA. Section 4 evaluates the proposed method through numerical simulations, comparative experiments, and a user study on collaborative fault recovery assisted by LLMs. Section 5 summarizes the research findings and outlines limitations and directions for future work.

2. Problem Formulation

Space missions typically select landing sites in polar regions, as these areas contain both highly illuminated regions (HIRs) and permanently shadowed regions (PSRs) in close proximity [30]. PSRs receive almost no direct sunlight and have been shown to harbor potential water–ice resources, making them critical targets for space exploration [31,32]. In contrast, HIRs benefit from abundant sunlight and are commonly chosen as landing sites to extend the mission duration [33].

As illustrated in Figure 1, the landing site for the mission considered in this study is located within an HIR. The base station, comprising habitation and laboratory modules, is situated on relatively flat terrain approximately 1 km from the landing site. From this station, assembly and sampling robots depart simultaneously: the assembly robot deploys solar panels within the HIR to harvest solar energy, whereas the sampling robot travels to PSRs to investigate water–ice resources. At this stage, variations among tasks of the same type and among robots of the same type are not considered.

2.1. KG-Based Modeling Framework for Space Missions

To uniformly represent robot, task, and related information, a KG is used to model the task allocation problem. Space missions are thus abstracted as a graph with semantic attributes:

$$G=({\mathcal{V}}_R,{\mathcal{V}}_T, \epsilon , S)$$

(1)

where ${\mathcal{V}}_{\mathrm{R}}$ denotes the set of robot nodes, ${\mathcal{V}}_T$ denotes the set of task nodes, $\epsilon$ denotes the edges between robot nodes and task nodes, and $S$ denotes the set of semantic attributes, including location, time, capability, value, etc. Specifically,

(1) Robot node. Taking robot $r_i$ as an example, to identify the factors that influence a robot’s suitability for executing a specific task, the state vector of $r_i\in {\mathcal{V}}_R$ is defined as

$$s_{r_i}=(p_i,v_i,c_i,{\tau }_i,{type}_i)$$

(2)

where $p_i$ denotes the robot’s current position; $v_i$ denotes its current velocity; $c_i$ represents the energy consumption coefficient per unit distance; ${\tau }_i$ indicates the earliest time at which the robot can execute the next task; and ${type}_i\in \left\{Sampling, Assembly\right\}$ specifies the robot’s operational category, which is used together with a static compatibility matrix to determine whether the robot is capable of executing a given task:

$$CM({type}_i,{type}_j)=\left\{\begin{array}{c}1,\mathrm{compatible}\hfill \\ 0,\mathrm{incompatible}\hfill \end{array}\right.$$

(3)

(2) Task node. Taking task $t_j$ as an example, although sampling and assembly tasks are both mission objectives, their semantics differ substantially. Therefore, task nodes must represent not only positional and reward-related information but also additional attributes such as time windows, execution duration, value decay, and task type. These attributes enable subsequent algorithms to compute utility in a manner consistent with each task’s semantic characteristics. For task $t_j\in {\mathcal{V}}_T$, the state vector is defined as

$$s_{t_j}=(p_j,w_j,\left[{\alpha }_j,{\beta }_j\right],d_j,{\lambda }_j,{type}_j)$$

(4)

where $p_j$ denotes the task location; $w_j$ denotes the task value; $\left[{\alpha }_j,{\beta }_j\right]$ represents the allowable time window; $d_j$ is the execution duration; ${\lambda }_j$ is the value discount factor; and ${type}_j\in \left\{Sampling, Assembly\right\}$ specifies the task category used to determine executability with ${type}_i$.

(3) Semantic properties of task–robot edges. Assuming task–robot compatibility, if $CM({type}_i,{type}_j)=1$, a semantic edge $e_{ij}$ is constructed. Factors such as distance, arrival time, and energy consumption between the robot and the task are determined by their geometric relationship and must therefore be explicitly represented as edge properties in the KG. For the semantic edge $e_{ij}$, the associated semantic properties are defined as:

• Discounted Value. This property represents the decreasing value of tasks over time, encouraging robots to execute tasks earlier to minimize delays.

  $$V_j(t)=w_j·e^{-{\lambda }_j·(t-{\alpha }_j)}$$

  (5)
• Spatial Distance. This property denotes the Euclidean distance between robot $r_i$ and task $t_j$, forming the basis for subsequent calculations. A shorter distance reduces execution cost and increases execution efficiency.

  $$d_{ij}=‖p_i-p_j‖$$

  (6)
• Travel Time. This property represents the time required for robot $r_i$ to reach task $t_j$ from its current position, converting spatial distance into a temporal cost to evaluate task feasibility.

  $$t_{ij}^{travel}={\displaystyle \frac{d_{ij}}{v_i}}$$

  (7)
• Time Urgency. This metric quantifies the urgency for robot $r_i$ to execute task $t_j$, enabling prioritization of time-sensitive tasks and prevention of potential time-window violations.

  $$U_{ij}^{time}=1-{\displaystyle \frac{t_{ij}^{travel}}{{\beta }_j-{\tau }_i}}$$

  (8)
• Value Density. This metric represents the value density of task $t_j$ relative to robot $r_i$, measuring the task’s value per unit distance and supporting optimization of overall benefit.

  $$U_{ij}^{value}={\displaystyle \frac{w_j}{d_{ij}}}$$

  (9)
• Fuel Cost. This metric represents the energy expenditure required for robot $r_i$ to execute task $t_j$, quantifying resource consumption during task execution.

  $$C_{ij}^{fuel}=c_i·d_{ij}$$

  (10)

Some semantic properties share underlying variables but represent different semantic dimensions rather than redundant factors. For example, spatial distance captures the geometric proximity between a robot and a task and serves as a feasibility and cost-related indicator, whereas value density evaluates the task’s benefit efficiency by relating task value to the required travel distance. Although both terms involve distance, one reflects absolute spatial constraints while the other characterizes relative benefit–cost efficiency, illustrating that shared inputs do not imply semantic redundancy.

2.2. Task Allocation Objectives

The primary objective of space missions is not merely to maximize the number of completed tasks but to optimize scientific value and overall system efficiency. Tasks differ in relative importance, time-decay rates, and execution costs. Therefore, a comprehensive utility metric is required rather than simple cost-based measures. The semantic-enhanced utility integrates spatiotemporal information, robot capabilities, resource costs, and task value into a unified decision metric, enabling heterogeneous robots to compute optimal task sequences in a consistent and rational manner.

Given a set of robots and a set of tasks, the objective of task allocation is to maximize the total semantic-enhanced utility across all robot–task assignments:

$$\underset{X}{\max }J=\sum _{i=1}^{N_r}\sum _{j=1}^{N_t}{U}_{ij}{x}_{ij}$$

(11)

where $X$ denotes the set of assignment variables; $N_r$ and $N_t$ represent the total numbers of robots and tasks, respectively; $x_{ij}\in \left\{0,1\right\}$ is a binary variable indicating whether robot $r_i$ executes task $t_j$; and $U_{ij}$ denotes the semantic-enhanced utility function, which is analogous to the core bidding function in CBBA (see Equation (12)).

3. Methodology of KG-CBBA

To address the challenges of MRTA in space exploration, this section presents the KG-CBBA method, which extends and enhances the traditional CBBA framework through KG integration. As illustrated in Figure 2, the method comprises two stages: static and dynamic allocation. At mission initiation, the static allocation iteratively performs bundle construction and static conflict resolution until all robots reach consensus on task bundles. When contingencies occur, the astronaut uses LLMs to conduct fault analysis, with task nodes generated accordingly. The dynamic allocation then takes these task nodes as input and reenters the iterative process of bundle construction and dynamic conflict resolution, continuing until the robots again achieve consensus on the updated bundles.

Among these, the core advancement of KG-CBBA lies in a semantic-enhanced utility function $U_{ij}$, which replaces the original CBBA utility with a KG-driven utility formulation. By incorporating spatiotemporal features, capability factors, resource costs, and value-related properties encoded in Equations (5)–(10), $U_{ij}$ enables robots to compute task utilities that more accurately reflect operational priorities in space environments. This enhanced utility serves as the foundation for bidding during bundle construction and directly influences the convergence quality of both the static and dynamic allocation phases.

$$U_{ij}={w_1·V_j\left(t\right)+w}_2·{\displaystyle \frac{1}{d_{ij}}}+w_3·V_j(t_{ij}^{travel})+w_4·U_{ij}^{time}+w_5·U_{ij}^{value}-w_6·C_{ij}^{fuel}$$

(12)

Meanwhile, the task allocation process is further constrained by the standard CBBA [34] feasibility requirements, which include

• Robot–task compatibility: robot and task types must match;
• Time window constraint: the robot’s arrival time satisfies $t_{ij}^{travel}\le {\beta }_j$;
• Path feasibility constraint: the robot’s trajectory must be feasible;
• Exclusive task assignment: each task can be executed by at most one robot.

These constraints, together with the $U_{ij}$ values defined in the KG, form the complete optimization and consensus framework of KG-CBBA. Through iterative communication, each robot updates its locally perceived winning bids based on timestamp priority, utility comparison, and tie-breaking by robot ID. This mechanism ensures monotonic convergence toward a conflict-free task allocation solution.

3.1. MRTA Static Task Allocation

In the static allocation calculation of KG-CBBA, as illustrated in Figure 3, the process comprises four main phases, each corresponding to specific KG structures. In the Start phase, knowledge triples are utilized for bundle computation, allowing each robot to independently select tasks and record bid values. During the Bundle Build phase, robots initiate conflict resolution; for example, if R1 selects T1 and T2, and R2 selects T2, T3, and T4, then T2 becomes the conflicting task. In the Conflicts Resolved phase, R1 is assumed to win the bid-value comparison. KG-CBBA then performs two additional iterations. When no further conflicts requiring resolution are detected, convergence is achieved, and the method enters the Converged phase, where the KG records the final MRTA outcome.

Specifically, the KG-CBBA static task allocation performs distributed task assignment for a multi-robot system through iterative bundle construction and conflict resolution over the task set $T_{init}$. The process begins by constructing a communication graph $\mathcal{G}$ and initializing, for each robot $r_i$, the necessary intermediate data structures: an empty task bundle $B_i$, an execution path $P_i$, a bid table ${bid}_{ij}$, and a winner table ${winner}_{ij}$. These structures collectively support the computation of semantic-enhanced bids and the propagation of consensus information.

Subsequently, KG-CBBA constructs the KG $G_{init}$ in which robots and tasks are represented as nodes, and the relationship $e_{ij}$ between robot $r_i$ and task $t_j$ is encoded as an edge enriched with semantic attributes.

$$G_{init}=({\mathcal{V}}_R,{\mathcal{V}}_T^{init}, \epsilon , S)$$

(13)

For each robot, a subgraph ${\mathcal{L}}_i$ is constructed, comprising all compatible task nodes and their corresponding edges. The static algorithm then iteratively performs bundle construction and conflict resolution until convergence is achieved.

In each iteration, the communication phase begins with robots exchanging ${\mathcal{L}}_i$ with adjacent robots according to the communication topology. Through this consensus mechanism, each robot updates its internal data structures, including the current winning robot ${winner}_{ij}$ and the highest bid value ${bid}_{ij}$ for each task. During the bundle addition phase, if a robot computes ${bid}_{ij}$ for all tasks and identifies multiple tasks with identical values, it selects the task with the earliest start time.

$${{bid}_{ij}=U}_{ij}$$

(14)

$${winner}_{ij}=\underset{i}{\mathit{argmax}} {bid}_{ij}$$

(15)

The timestamp matrix $t$ is regularly synchronized to ensure consistency across all robots’ ${\mathcal{L}}_i$. This design enables the algorithm to maintain a global state in a distributed manner, while each robot only needs to store its local ${\mathcal{L}}_i$, thereby reducing both communication and computational overhead. In addition, a full-graph iteration counter $T$ is introduced to trigger periodic synchronization every five iterations, preventing information loss due to unstable communication or transmission delays.

After the communication phase, each robot enters the conflict resolution phase. It first removes from $B_i$ any tasks that have been outbid by other robots based on updated graph information. The robot then computes $U_{ij}$ for each unassigned task and iteratively adds new tasks to $B_i$. For each candidate task, it evaluates all feasible insertion points within its current $P_i$, and selects the position that maximizes utility while satisfying all feasibility constraints.

The robot selects the task with the highest bid value, which must either exceed the current winning bid recorded in the graph or satisfy the tie-breaking rule favoring the robot with the smaller ID. Once selected, the task is inserted into $B_i$ and $P_i$ at the optimal position, and ${\mathcal{L}}_i$ is subsequently updated.

The algorithm continues until no new bids are submitted by any robot for a consecutive number of iterations equal to the number of robots $N_r$, indicating that convergence has been reached. Finally, task indices are mapped to their corresponding task IDs to produce the static assignment scheme $X_{init}$. The overall procedure of the KG-CBBA static allocation algorithm is summarized in Algorithm 1.

Algorithm 1: KG-CBBA static task allocation

Input:  The set of robot nodes ${\mathcal{V}}_R$ and the set of task nodes ${\mathcal{V}}_T$. Output:  Static assignment scheme $X_{init}$.

1.  Initialization: Set KG-CBBA parameters and the communication graph $\mathcal{G}$. Initialize data structures for each robot $r_i$, including the task bundle $B_i$, execution path $P_i$, bid value ${bid}_{ij}$, and winner ${winner}_{ij}$. Set the global iteration counter $T=1$.

2.  Semantic Graph Construction: Construct the graph $G_{init}=({\mathcal{V}}_R,{\mathcal{V}}_T^{init}, \epsilon , S)$. Establish edges $e_{ij}$ between robot nodes $r_i$ and compatible task nodes $t_j$. For each robot node $r_i$, construct a subgraph ${\mathcal{L}}_i$ containing all compatible task nodes and edges. 3.  Iteration: If convergence has not been reached: 4.        Communication Phase: Each robot $r_i$ exchanges its subgraph ${\mathcal{L}}_i$ with adjacent robots according to the communication topology. Update ${bid}_{ij}$ and ${winner}_{ij}$ via the consensus mechanism, and update the distributed timestamp matrix $t$. 5.        Graph Synchronization: If $T \mathrm{m}\mathrm{o}\mathrm{d} 5=0$, perform graph synchronization across all robot nodes. 6.        Task-Bundle Construction: For each robot $r_i$: 7.              Task Removal: Remove tasks from $B_i$ that have been outbid based on ${\mathcal{L}}_i$. 8.              Task Addition: If $B_i$ is not full: 9.                      Bid Calculation: For each unassigned task $t_j$, compute the semantic utility $U_{ij}$ and determine the optimal insertion position within $P_i$. 10.                    Task Selection: Choose the task $t^{*}$ with the highest bid value ${bid}_{ij}$ from ${\mathcal{L}}_i$, provided that ${bid}_{ij}$ exceeds $t^{*}’$s current bid or satisfies the tie-breaking rule.

11.                    Update Task Bundle: Insert $t^{*}$ into $B_i$ at the optimal position in $P_i$, and update ${\mathcal{L}}_i$, ${bid}_{ij},$ and ${winner}_{ij}$. 12.        Convergence Check: If no new bids are submitted for $N_r$ consecutive iterations, set the convergence flag; else $T=T+1$. 13.  Result Mapping: Convert task indices in $B_i$ and $P_i$ for each robot $r_i$ to task IDs. 14.  Return: $X_{init}=\left\{\left(B_1,P_1\right),\left(B_2,P_2\right),\dots ,\left(B_{N_r},P_{N_r}\right)\right\}$

3.2. MRTA Dynamic Task Allocation

The KG-CBBA dynamic task allocation algorithm addresses scenarios in which tasks are dynamically introduced after the completion of static allocation. In context of LLM-assisted fault analysis, three typical cases are considered: task addition, task modification, and task deletion. When tasks are deleted, the system directly cancels all subsequent tasks along that route. Deletion decisions primarily aim to enable a safe return to the base while conserving remaining resources, without necessitating reassignment. Thus, the algorithm focuses only on scenarios involving task addition and modification, as shown in Figure 4.

Among these, adding new task nodes involves dynamically generating tasks and assigning IDs for allocation after the current task sequence, while preserving the existing static allocation scheme. Modifying task nodes entails clearing the semantic attributes of the corresponding task bundle and updating them based on the results of fault analysis. These tasks are then dynamically reassigned as new tasks, while preserving the remaining static allocation scheme. Importantly, the scalability of KG-CBBA dependents not on the absolute problem size, but on its methodological design. By jointly modeling static task allocation (Figure 3) and dynamically arriving tasks within an incrementally extensible KG, KG-CBBA enables localized updates and distributed bidding over task–robot subgraphs. This KG-driven formulation naturally supports expansion of both task and robot sets without requiring global recomputation, highlighting the scalability advantages of the proposed approach from a methodological perspective.

The KG-CBBA dynamic allocation algorithm addresses only the dynamic task set $T_{new}$ and does not modify the statically allocated $X_{init}$. While dynamically allocating all remaining resources could, in theory, achieve a global optimum, such an approach may introduce potential risks in the context of space exploration missions. End-to-end static allocation is difficult to standardize for space exploration due to unstructured environments and non-cooperative tasks, thus requiring human review and adjustment. Therefore, the KG-CBBA adopts incremental allocation, aiming to achieve the best possible outcome under safety constraints, rather than pursuing a theoretical global optimum.

The algorithm begins by merging the static task ${\mathcal{V}}_T^{init}$ with newly arrived tasks ${\mathcal{V}}_T^{new}$, while maintaining a clear distinction between initial and new tasks through a tag array $D$. It then initializes a local graph view ${\mathcal{L}}_i$ for each robot. Crucially, the algorithm preserves $X_{init}$ by mapping task IDs to static allocation information, including ${winner}_{ij}$, ${bid}_{ij}$, and ${\mathcal{L}}_i$ for each task.

$$G_{new}=({\mathcal{V}}_R,{\mathcal{V}}_T^{init}\cup {\mathcal{V}}_T^{new}, \epsilon , S)$$

(16)

${\mathcal{V}}_T^{new}$ is initialized to an unassigned state, and bids for static tasks are cleared to prevent rebidding on already assigned tasks. During the bundle construction phase, robots remove new tasks from $B_i$ only if they have been outbid, while all static tasks remain unchanged through bid filtering.

$$D\left(1:{\mathcal{V}}_T^{init}\right)=0$$

(17)

When adding tasks to $B_i$, each robot computes the semantic-enhanced utility $U_{ij}$ for tasks in ${\mathcal{V}}_T^{new}$. The filtering mechanism explicitly prevents bidding on any static tasks, thereby ensuring the integrity of the static allocation while allowing robots to compete for new tasks.

$${{bid}_{ij}^{new}=U}_{ij}, t_j\in T_{new}$$

(18)

Subsequently, each robot attempts to insert the new task into all valid positions within its existing path $P_i$. It then verifies the feasibility of the time window, path order, and energy consumption constraints. If the task is feasible, it is incorporated into the path, and ${\mathcal{L}}_i$ is updated simultaneously to reflect the robot’s declaration.

$$P_{i^{new}}=P_i\oplus t_j$$

(19)

$${winner}_j=\underset{i}{\mathit{argmax}} {bid}_{ij}^{new}$$

(20)

If no new bids are submitted during the current round, convergence is achieved, and the dynamic allocation process is considered complete.

$$\forall t_j\in T_{new}: {winner}_j^k={winner}_j^{k-1}$$

(21)

The overall procedure of the KG-CBBA dynamic allocation algorithm is summarized as Algorithm 2.

Algorithm 2: KG-CBBA dynamic task allocation

Input:  The set of robot nodes ${\mathcal{V}}_R$, the set of task nodes ${\mathcal{V}}_T$, static assignment scheme $X_{init}$, the set of new task nodes ${\mathcal{V}}_T^{new}$. Output:  Dynamic assignment scheme $X_{dynamic}$.

1.  Initialization: Set KG-CBBA parameters and the communication graph $\mathcal{G}$. Initialize data structures for each robot $r_i$, including the task bundle $B_i$, execution path $P_i$, bid value ${bid}_{ij}$, and winner ${winner}_{ij}$. Set the global iteration counter $T=1$.

2.  Semantic Graph Construction: Construct the graph $G_{new}= ({\mathcal{V}}_R,{\mathcal{V}}_T^{init}\cup {\mathcal{V}}_T^{new}, \epsilon , S)$. Establish edges $e_{ij}$ between robot nodes $r_i$ and compatible task nodes $t_j$. For each robot node $r_i$, construct a subgraph ${\mathcal{L}}_i$ containing all compatible task nodes and edges. 3.  Preserve Initial Assignments: Map task IDs in $B_i$ and $P_i$ from the static assignment scheme $X_{init}$ to task indices. Update ${\mathcal{L}}_i$ to include static assignment details and construct a tag array $D$ to mark initial tasks. 4.  Prepare New Tasks: Initialize ${\mathcal{V}}_T^{new}$ to unassigned state and clear bids for static tasks. 5.  Initialize Iteration Structures: Set global iteration counter $T=1$ and initialize the distributed timestamp matrix $t$. 6.  Iteration: If convergence has not been reached: 7.        Communication Phase: Each robot $r_i$ exchanges its subgraph ${\mathcal{L}}_i$ with adjacent robots according to the communication topology. Update ${bid}_{ij}$ and ${winner}_{ij}$ via the consensus mechanism, and update the distributed timestamp matrix $t$. 8.        Graph Synchronization: If $T \mathrm{m}\mathrm{o}\mathrm{d} 5=0$, perform graph synchronization across all robot nodes.

9.        New Task-Bundle Construction: For each robot $r_i$: 10.              Task Removal: Remove newly assigned tasks from $B_i$ that have been outbid based on ${\mathcal{L}}_i$.

11.              Task Addition: If $B_i$ is not full: 12.                    Bid Calculation: For each unassigned task $t_j$, compute the semantic utility $U_{ij}$ and determine the optimal insertion position within $P_i$ 13.                    Bid Filtering: Set $D\left(1:{\mathcal{V}}_T^{init}\right)=0$ to prevent bidding on initial tasks. 14.                    Task Selection: Choose the task $t^{*}\in {\mathcal{L}}_i$ with the highest bid ${bid}_{ij}$, provided that ${bid}_{ij}$ exceeds $t^{*}$’s current bid or satisfies tie-breaking conditions. 15.                    Update Task Bundle: Insert $t^{*}$ into $B_i$ at the optimal position in $P_{i^{new}}$, and update ${\mathcal{L}}_i,$ ${bid}_{ij}$, and, ${winner}_{ij}$. 16.        Convergence Check: If no new bids exist for new tasks, set the convergence flag; else $T=T+1$. 17.  Result Mapping: Convert task indices in $B_i$ and $P_{i^{new}}$ for each robot $r_i$ to task IDs. 18.  Return: $X_{dynamic}=\left\{\left(B_1,P_1\right),\left(B_2,P_2\right),\dots ,\left(B_{N_r},P_{N_r}\right)\right\}$

4. Numerical Simulations and User Study

This section first presents the experimental setup used to demonstrate the solution process of KG-CBBA, including its application to task adjustment and task addition. Next, KG-CBBA is compared with standard CBBA, centralized PSO, and greedy baselines to highlight its performance advantages. Finally, a user study evaluates the integration of KG-CBBA with LLMs for fault recovery, comparing it with traditional approaches that rely primarily on fault manuals to validate the effectiveness of the proposed collaboration mechanism.

4.1. Experimental Setup

To validate the performance of the proposed algorithm, sampling and assembly tasks were selected as simulation scenarios. In this setup, the assembly robot is responsible for assembling solar panels in the HIR to collect solar energy, while the sampling robot must travel to the PSR to detect water–ice resources. As shown in Figure 5, all robots are assumed to start from the base at coordinates (0, 0) within a 10 × 10 operational area. The assembly robot performs randomly generated assembly tasks in the HIR region (0 < x < 5, 0 < y < 5), whereas the sampling robot executes randomly generated sampling tasks in the PSR region (5 < x < 10, 5 < y < 10). All spatial parameters in the simulation are defined in normalized units, with the purpose of ensuring fair and consistent comparisons across different allocation methods rather than representing a specific physical scale of space exploration missions. These area constraints are introduced to reflect the unstructured and non-cooperative characteristics inherent to the space environment.

The MRTA simulation parameters are summarized in

Table 1. MRTA Simulation Parameters.

Type	Assembly Task	Sampling Task
Task Numbers	$\left\{T_1,T_2,{\dots ,T}_{10}\right\}$	$\left\{T_{11},T_{12},{\dots ,T}_{20}\right\}$
Task Value $w_j$	100	100
Time Window $\left[{\alpha }_j,{\beta }_j\right]$	120 s	120 s
Duration	5 s	15 s
Discount Factor ${\lambda }_j$	0.1	0.1

. Eight robots were used, evenly divided between sampling and assembly robots. Twenty tasks were generated, with an equal number assigned to sampling and assembly categories. It should be noted that the number of robots and tasks in the simulation is not intended to represent the full scale of real space exploration missions. Instead, this configuration is adopted to maintain consistency with existing MRTA studies [22,23] and to ensure a fair comparison among distributed (CBBA, KG-CBBA), centralized (PSO), and heuristic (greedy) approaches under identical conditions.

The semantic attribute weights used in the semantic-enhanced utility function are reported in

Table 2. Semantic Attribute Weight of Semantic Augmentation Functions.

Type	Value
Discounted Value $w_1$	1.0
Space Distance $w_2$	0.1
Travel Time $w_3$	0.1
Time Urgency $w_4$	0.1
Value Density $w_5$	1.0
Fuel Cost $w_6$	0.05

. The weight parameters were selected to ensure compatibility with, and fair comparison against, the original CBBA. Specifically, $w_1=1.0$ and $w_5=1.0$ correspond to the coefficients of the discounted value and fuel cost terms in CBBA’s scoring function, thereby preserving its core decision-making logic. The additional semantic weights ($w_2=0.1$, $w_3=0.1$, $w_4=0.1$, and $w_6=0.05$) are intentionally set to small values so that they serve as supplementary factors without dominating CBBA’s primary mechanisms. Given the scenario-dependent feasibility of dynamic MRTA, we assess the influence of the utility design through a controlled ablation of the core semantic terms, as detailed in the subsequent ablation experiments. These default values are used as benchmark parameters to enable objective comparison under identical experimental conditions, rather than being tuned for any specific real-world scenario. In practical deployments, they should be calibrated through domain-specific optimization or learned from historical experiment data. All experiments were conducted in MATLAB R2017a on a system equipped with a 12th Gen Intel^® Core™ i7-12700 2.10 GHz.

4.2. Feasibility Experiment

4.2.1. Task Adjustment Experiment

Figure 6a presents the Gantt chart for the static task allocation across all robots, with each row corresponding to a single robot. Robots 1–4 represent assembly robots, while robots 5–8 represent sampling robots. Blue and orange bars denote assembly and sampling tasks, respectively, and rectangle indicates the execution duration of a task. Figure 7a illustrates the corresponding execution paths, demonstrating that the randomly generated task locations satisfy the spatial constraints shown in Figure 5.

Assume that during a sampling mission, an early failure occurs due to an excessively low recognition threshold, resulting in multiple targets being identified. Then astronauts rely on the LLM to assist in decision-making, aiming to increase the priority of task T17. Accordingly, T17 is removed from the static allocation at t = 20 s, its value $w_j$ is increased to 1500, and its time window is adjusted to begin at t = 20 s, making it immediately available. As shown in Figure 6b and Figure 7b, T17 (highlighted by the green mask) was successfully reassigned through the dynamic allocation algorithm. By leveraging the combined effects of value enhancement and time window adjustment, T17 was transferred from Robot 7 to Robot 6, enabling earlier completion while preserving other static task assignments.

4.2.2. Task Addition Experiment

Figure 8a and Figure 9a present the static task allocation Gantt chart and execution path for this scenario, following the same visualization style as in the previous subsection. The distinguishing assumption in the dynamic task addition experiment is that, during an assembly mission, real-time observation data indicates abnormal light intensity within a specific region. Astronauts then rely on the LLM-assisted decision module to dynamically insert a new assembly task at that location. Therefore, at t = 50 s, the newly added task T21 is defined as an assembly task, and its time window is adjusted to start = 50 s, making it immediately eligible for bidding. The resulting allocation, shown in Figure 8b and Figure 9b, demonstrates that T21 (highlighted by the green mask) is reassigned to robot 1 by the dynamic allocation algorithm through iterative optimization.

Overall, the task adjustment experiment and the task addition experiment jointly demonstrate that KG-CBBA fulfills the requirements for dynamic MRTA. The algorithm effectively handles both adjusted priority sampling tasks and newly added assembly tasks, enabling real-time reallocation while preserving the stability of the static assignments. This validates the capability of KG-CBBA to operate reliably under dynamic conditions.

4.3. Performance Experiment

To evaluate the effectiveness of KG-CBBA, we conducted a comparative analysis against 3 benchmark methods: (1) the standard CBBA [34], (2) the centralized PSO [35], and (3) greedy heuristic algorithm. Since CBBA, PSO, and the greedy algorithm lack standardized mechanisms for flexible task adjustment and dynamic reallocation, direct comparison under dynamic task adjustment conditions would be unfair. Therefore, for performance evaluation, we adopted a dynamic task addition setting, in which all four algorithms are triggered by the same task insertion event. In this setting, the initial static allocation is preserved and frozen, and only the newly added tasks are subject to replanning. Each algorithm thus operates in an incremental reallocation mode rather than global replanning, ensuring that all methods respond to the same dynamic coordination requirement and enabling a fair and consistent comparison across algorithms.

Under this unified setup, we quantified 3 key performance metrics: Scheduling Cost (total cost required to complete all tasks), Mileage Cost (total fuel consumption of all robots), and Task Waiting Cost (total waiting time incurred by all tasks), and the specific calculations can be found in Equations (22)–(24). Rather than directly optimizing cost-based metrics, the KG-CBBA employs a semantic-enhanced utility as the decision objective to support distributed bidding and winner determination, while cost metrics are used as post hoc indicators to evaluate the quality of the resulting allocations from space mission perspectives. By contrast, the PSO baseline directly minimizes these cost metrics in the centralized manner.

$$C_{\mathrm{s}\mathrm{c}\mathrm{h}\mathrm{e}\mathrm{d}}=\sum _{r_i\in {\mathcal{V}}_{\mathrm{R}}}{T}_{r_i}^{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{l}\mathrm{e}\mathrm{t}\mathrm{e}}$$

(22)

$$C_{Mileage}=\sum _{(r_i,t_j)\in X}{C}_{ij}^{fuel}$$

(23)

$$C_{Wait}=\sum _{(r_i,t_j)\in X}\mathrm{m}\mathrm{a}\mathrm{x} (0,t_{ij}^{\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{r}\mathrm{t}}-t_j^{\mathrm{r}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{a}\mathrm{s}\mathrm{e}})$$

(24)

where $T_{r_i}^{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{l}\mathrm{e}\mathrm{t}\mathrm{e}}$ denotes the completion time of robot $r_i$ after finishing its assigned task sequence, $t_{ij}^{\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{r}\mathrm{t}}$ is the actual start time at which robot $r_i$ begins task $t_j$, and $t_j^{\mathrm{r}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{a}\mathrm{s}\mathrm{e}}$ is the release time of task $t_j$.

For reproducibility, the PSO baseline uses a swarm size of 30, a maximum of 50 iterations, inertia weight linearly decreasing from 0.5 to 0.2, maximum velocity 2.0, cognitive and social coefficients $c_1=c_2=1.0$, and early stopping after 10 iterations without improvement. The greedy heuristic sorts tasks by earliest start time and assigns each task to the compatible agent minimizing local cost $C_{local}$ (Equation (25)). The PSO initialization uses a greedy feasible assignment, and its setting prioritizes feasibility preservation and convergence stability in a tightly constrained MRTA scenario rather than aggressive global exploration.

$$C_{local}=C_{\mathrm{s}\mathrm{c}\mathrm{h}\mathrm{e}\mathrm{d}}+C_{Mileage}+C_{Wait}$$

(25)

Each algorithm was executed for 100 Monte Carlo simulations, and the average results are reported in Figure 10. Given the NP-hard nature of dynamic MRTA problems and the random sampling inherent in Monte Carlo runs, performance variance can be substantial. Therefore, averaged results are reported to illustrate relative performance trends across different algorithms.

As shown in Figure 10, KG-CBBA exhibits superior performance across all 3 metrics, validating its effectiveness for dynamic allocation in space mission scenarios.

Scheduling Cost. KG-CBBA achieves the lowest Scheduling Cost at 501.53, representing reductions of 12.32% compared to CBBA (571.68), 4.90% compared to PSO (527.35), and 19.53% compared to the greedy algorithm (623.26). This highlights that the integration of KG-guided semantic enhancement enables KG-CBBA to achieve solutions with lower scheduling cost than baselines under tested settings.

Mileage Cost. KG-CBBA also achieves the lowest fuel consumption, with a Mileage Cost of 45.09, outperforming CBBA (52.67), PSO (51.41), and the greedy algorithm (47.95). While the spatial separation of sampling and assembly areas reduces variance in total travel distance across algorithms, the results clearly demonstrate KG-CBBA’s advantage in minimizing redundant travel and avoiding inefficient routing.

Task Waiting Cost. KG-CBBA further reduces Task Waiting Cost to 4.61 and, together with CBBA (6.23), demonstrates the effectiveness of distributed coordination in providing timely task servicing. In contrast, PSO (47.84) and the greedy algorithm (21.43) lead to substantial queuing and delays, highlighting their unsuitability for the space environment.

To examine the influence of semantic utility weights on task allocation performance, an ablation study was conducted by retaining only the key semantic-related weights while keeping the remaining terms inactive. In this setting, only the two weights ($w_1$ and $w_5$), corresponding to the core utility factors inherited from the original CBBA formulation, were retained, yielding the variant denoted as KG-CBBA (w₁, w₅). This configuration maintains the KG-based task representation while limiting the semantic richness of the utility function. Such a design enables a structured evaluation of whether performance gains arise solely from introducing of the KG or from the combined effect of the KG and additional semantic attributes, without altering the underlying CBBA mechanism. The KG-CBBA (w₁, w₅) variant was evaluated under the same 100 Monte Carlo trials, and the results are reported in Figure 11.

The results exhibit a clear and consistent performance trend across all cost metrics. Specifically, the full KG-CBBA achieves the lowest Scheduling cost (501.53), Mileage cost (45.09), and Task waiting cost (4.61). This is followed by KG-CBBA (w₁, w₅), which shows moderate increases (546.48, 47.89, and 5.35, respectively), while the original CBBA performs worst (571.86, 52.67, and 6.23, respectively). This monotonic degradation indicates that introducing a KG representation yields measurable performance gains over CBBA, and that incorporating additional semantic weighting further enhances allocation efficiency. The observed trend confirms the effectiveness of both the KG-based task representation and the proposed semantic utility design in constrained MRTA scenarios.

We note that PSO achieved lower Scheduling Costs than CBBA in our experiments, highlighting the advantage of centralized algorithms. However, when Task Waiting Costs are considered jointly, distributed and centralized approaches each exhibit distinct strengths and limitations. To further assess their practical efficiency, we compare the runtime metrics across these 100 Monte Carlo experiments. This metric serves as a critical benchmark in dynamic allocation contexts [22], as illustrated in Figure 12.

Although PSO achieves lower Scheduling Costs than CBBA, it relies on centralized global computation, resulting in an average runtime of 1.46 s, which is substantially higher than KG-CBBA (0.16 s), CBBA (0.03 s), and the greedy algorithm (0.01 s). This makes PSO unsuitable under the imposed incremental replanning protocol and tested runtime constraints. While CBBA operates faster than KG-CBBA, its overall costs remain higher. KG-CBBA strikes an effective balance: by integrating a KG to enhance task understanding, it reduces overall costs while retaining a distributed architecture and high performance, thereby achieving a more favorable cost-efficiency tradeoff.

4.4. User Study

In accordance with the university’s ethical review guidelines for research involving human participants, this study was reviewed by the relevant Institutional Review Board and was granted an exemption from formal ethical approval requirements. The experiment did not involve clinical trials with humans or animals, posed no ethical risks, and adhered to established standards for voluntary participation. A total of 96 participants (51 males, 45 females; aged 18–30 years, M = 22.79, SD = 2.21) were recruited through campus social networks for the user study. All participants had corrected visual acuity of 4.8 or higher, normal color vision, and were right-handed. Each participant provided written informed consent, fully understood the purpose of the study, and received compensation for participation. Participants were free to withdraw at any time, and all associated data were deleted upon withdrawal.

The experimental procedure is illustrated in Figure 13. A simulation of the assembly and sampling tasks was developed in Unity 3D, with duplex communication implemented via WebSocket. Due to confidentiality requirements, the detailed experimental procedures and user interface cannot be disclosed; instead, we provide an overview of the task workflow. Each robot autonomously executes tasks until encountering a fault, at which point volunteers employ the LLM for fault analysis and collaborate with KG-CBBA to complete MRTA, followed by decision for fault recovery.

During preliminary experiments, we observed a pronounced learning effect in both KG-CBBA/LLM collaboration and traditional manual-based fault recovery, which could compromise experimental accuracy. To mitigate this, each volunteer in the user study was randomly assigned to one task type (sampling or assembly) and one mode (proposed or traditional), resulting in 24 data points per group for analysis.

The LLM used is based on ChatGLM-6B and adapted for fault analysis via P-tuning, as detailed in prior work [14]. It is fine-tuned to interpret task information and generate recommendations. For detected fault, the LLM provides outputs, which serve as guidance to participants. A decision attempt is defined as a single user choice made in response to a detected fault, and trials terminate upon successful completion of the assigned task without an explicit time limit. Participants were provided with standardized instructions describing overall task objectives and fault-handling procedures. Representative fault scenarios mirror those used in the feasibility experiments: the sampling task involves target localization, path planning, obstacle avoidance, navigation, and object grasping, while the assembly task involves target localization, component grasping, navigation, and assembly execution. In traditional baseline, participants receive all necessary task and fault-related information via a paper-based fault manual, but do not receive LLM or KG-CBBA recommendations. This setup allows a fair comparison between proposed and manual decision-making while providing sufficient methodological detail for independent understanding and interpretation of the results.

We recorded the number of decisions required by volunteers to complete the tasks and specifically examined the probability of achieving a successful first-time decision. Results are presented in Figure 14. The user study is designed to observe first-time between-subject interaction behaviors under learning-sensitive conditions. Therefore, results are reported descriptively to characterize behavioral tendencies rather than to support inferential difference testing.

As shown in Figure 14a, the proposed method exhibits observable differences in fault recovery behavior compared with the traditional approach. In the assembly task, the average number of decision attempts was 2.50 (SD = 1.47) under the proposed method, compared with 3.08 (SD = 1.35) for the traditional approach. For the sampling task, the proposed method required an average of 3.21 attempts (SD = 2.34), whereas the traditional method required 9.67 attempts on average (SD = 10.27). The performance gap between the two methods appears more pronounced in the sampling task. This may be attributed to the assembly task being confined to the HIR, which involves fewer environmental changes than the transition from HIR to PSR in the sampling task, allowing volunteers to adapt more easily and make fewer decisions.

In terms of first-time success rates (Figure 14b), the traditional approach achieved 12.50% (3 participants) for both task types. By contrast, the proposed method achieved 29.17% (7 participants) for the sampling task and 33.33% (8 participants) for the assembly task. These results indicate a tendency toward improved fault recovery efficiency when LLM-based assistance and KG-CBBA are provided, offering empirical insights into their potential role in supporting human–robot collaboration in space exploration scenarios.

5. Conclusions

This paper proposes the KG-CBBA method that integrates a KG-based representation with the CBBA mechanism to address the MRTA problem in space exploration. First, a KG for space missions is constructed to organize mission components along with their associated constraints and objectives, enabling semantically informed task allocation in complex MRTA scenarios. Next, a distributed computing architecture applicable to both static and dynamic task allocation is designed. The static allocation algorithm establishes a globally consistent task assignment by incorporating semantic attributes, compatibility relationships, and distributed timestamp synchronization into the bidding and consensus processes. Building on this foundation, the dynamic allocation algorithm supports real-time adaptation to newly added or modified tasks. By introducing tag arrays, bid filtering, and incremental bundle construction, the algorithm ensures that only the dynamic tasks participate in dynamic bidding. The integration of static and dynamic algorithms enables KG-CBBA to efficiently allocate tasks, ensure feasibility under constraints, and incrementally update assignments in response to operational changes.

Simulation results demonstrate that the proposed method provides a viable solution for newly added and modified tasks. Comparative experiments with standard CBBA, centralized PSO, and greedy allocation methods confirm that KG-CBBA achieves superior performance in scheduling cost, mileage cost, and task waiting cost, while maintaining reasonable runtime. Furthermore, user study illustrated trends in the human-in-the-loop collaborative approach, in which fault recovery is executed through the cooperative operation of KG-CBBA and an LLM. Compared with traditional methods that rely primarily on fault manuals, this approach tended to reduce the average number of decisions and increase first-time success rates.

Although KG-CBBA demonstrates strong performance in modeling space missions within the constructed KG framework, several limitations remain. As space exploration advances and more robot-level operational data become available, the semantic-enhanced utility could be further extended to incorporate additional constraints, such as explicit battery capacity limits or feasibility thresholds, and LLMs may be employed to support task execution through chain-of-thought reasoning [36]. The KG could also be leveraged for potential risk estimation [37], thereby expanding the scope of fault recovery modeling and providing KG-CBBA with more comprehensive and flexible semantic attribute inputs. Finally, long-term mission operations may allow for adaptive adjustment of the semantic-enhanced utility weights tailored to different tasks.