Dynamic Task-Chain Reconfiguration for Cooperative Counter-UAV Defense: A Multi-Agent Large Language Model Framework for Automated Heuristic Design

1. Introduction

Small unmanned aerial vehicles (UAVs) are increasingly low-cost, mobile, and able to operate in swarms, and the resulting low-altitude threats can no longer be neutralized by detecting a single target and intercepting it once. Effective defense is instead a continuous process that links detection, identification, tracking, threat assessment, task assignment, and engagement. Surveys of counter-UAV and cooperative counter-unmanned aircraft system defense consistently conclude that no single sensor or engagement resource can close this loop alone, and that a realistic defense couples detection, tracking, classification, command and control, and engagement across several platforms [1,2]. Counter-UAV defense is therefore best understood as the goal-oriented organization of cooperative task chains—ordered combinations of sensing, coordination, and engagement actions that together carry a single target from detection to neutralization—rather than as an isolated choice of one technique for one stage.

In such a scenario a UAV plays two roles at once: an intruding UAV is a target to be detected, tracked, and engaged, whereas a defending UAV takes on a sensing, coordination, or engagement role according to its payload. A target is handled only when its task chain forms an executable closed loop that joins at least one sensing node to one engagement node, optionally through a coordination node. Studies of swarm resilience and dynamic task allocation show that limited communication, node failure, changing tasks, platform state, and real-time constraints all erode this cooperative capability [3,4]. For a counter-UAV task chain the most immediate risk is structural: when a defending node is lost—to hostile fire, jamming, or power depletion—the chains that pass through it are severed, so that targets remain in the area yet can no longer be engaged by any executable loop.

How to repair such damage has been studied mostly under the banner of dynamic task allocation, where mission reward, resource consumption, chain structure, and the mix of node types are shown to jointly determine effectiveness in a changing environment [5,6,7]. The prevailing response to a change of state, however, is to re-solve the allocation from scratch, and comparatively little attention is paid to how surviving chains should be inherited after a disturbance, how targets should be prioritized for recovery, and how collateral change to the still-intact chains should be contained. Yet in a contested low-altitude setting it is precisely these factors—inheritance, selective recovery, and stability—that decide whether executable task chains can be restored quickly and without destabilizing the parts of the plan that the disturbance left untouched.

This paper accordingly studies the dynamic reconfiguration of cooperative counter-UAV task chains. Given a plan that already exists before a disturbance and the set of defending nodes that fail during the current period, the system must produce a new plan that uses none of the failed nodes. Reconfiguration is deliberately not treated as a one-off re-solving of a static problem: the broken chains should recover as much engagement effectiveness as possible, while the links of the existing plan should be changed no more than necessary. Because sensing and engagement nodes have limited capacity, and a coordination node raises effectiveness only at the cost of added delay and capacity, the task becomes a multi-objective combinatorial optimization problem jointly constrained by capacity, reachability, chain integrity, and time windows—a formulation that makes the trade-off between recovery and disturbance explicit and quantifiable.

Searching this space efficiently usually relies on heuristic rules, but rules crafted by hand struggle to adapt at once to the many node-loss patterns, threat levels, and chain delay structures that a disturbance can produce. Recent work on automated heuristic design (AHD) driven by large language models (LLMs) shows that a language model can take part in constructing heuristics through program search, evolutionary generation, and reflective feedback, and can return executable, quantitatively evaluable algorithms rather than prose advice [8,9,10]. Two hypotheses follow and are tested in this paper: first, that heuristics generated automatically and specialized to reconfiguration actions preserve solution quality as the problem scales, where fixed hand-crafted rules do not; and second, that distributing the heuristic-design loop across cooperating, specialized LLM agents yields more reliable heuristics than a single-agent loop. We therefore apply AHD to task-chain reconfiguration, so that the object it generates shifts from a generic allocation score toward recovery heuristics oriented to chain keeping, node replacement, chain-type switching, and reconfiguration-cost control.

The main contributions of this paper are fourfold. First, we formulate the dynamic reconfiguration of counter-UAV task chains as a problem in its own right: a baseline plan is given and part of the defending nodes have failed, and a new plan must be rebuilt from the surviving links. Unlike full reallocation, this formulation makes the inheritance of the historical plan, the recovery of capability after a disturbance, and the stability of the unaffected chains first-class concerns. Second, we build a constrained bi-objective model that couples recovery with disturbance: the total weighted engagement effectiveness of the reconstructed plan, $F_A$, measures recovery, while the link-change distance to the baseline plan, $F_D$, measures the disturbance imposed on the existing plan, which renders the conflict between high recovery and low disturbance explicit. Third, we propose Multi-Agent Heuristic Evolution (MAHE), an automated heuristic design framework in which evolution, coordinator, repair, and reflection agents driven by an LLM evolve scoring heuristics confined to task-chain reconfiguration—producing logic for chain keeping, insertion, node replacement, chain-type switching, and chain release rather than a static node-target matching score. Fourth, we instantiate the problem in a low-altitude counter-UAV setting and evaluate it extensively against hand-crafted multi-objective solvers and a single-agent heuristic-design baseline; the experiments show that MAHE maintains a consistently high solution quality as the numbers of nodes and targets grow, while the hand-crafted solvers degrade sharply, and an ablation confirms that its reflection, repair, and coordinator agents contribute complementary and increasingly decisive gains at larger scales.

The remainder of this paper is organized as follows. Section 2 reviews cooperative counter-UAV defense and task-chain modeling, dynamic multi-UAV task allocation, resilient reconfiguration under disturbance, and LLM-based automated heuristic design. Section 3 states the problem and the bi-objective model of cooperative task-chain dynamic reconfiguration. Section 4 details the MAHE framework. Section 5 reports the experimental design, the evaluation metrics, and the results. Section 6 concludes the paper, and Section 7 discusses future research directions.

2. Related Work

2.1. Task-Chain Modeling for Cooperative Counter-UAV Defense

The swarming of small UAVs has introduced a class of low-altitude security threats that no single platform can resolve in isolation [11], and counter-UAV defense is consequently described as a continuous process composed of detection, tracking, classification, and engagement. Ghazlane et al. [12] organize counter-UAV systems along this same process and conclude that no single sensing or engagement means can close the response loop alone; at the level of an individual stage, perception techniques such as YOLOv3-based counter-UAV tracking [13] provide only the input at the front of the loop. Castrillo et al. [2] examine cooperative defensive teams of drones and argue that cooperation across sensing, command and control, communication, and engagement compensates for the limited coverage, response speed, and engagement capacity of any single platform, while work on the protection of airports and other critical facilities integrates detection, cybersecurity risk, and risk management within a single framework [14]. Since different engagement means trade resource consumption against response time and mission effectiveness [15], the central design question is not which technique to select for a single stage but how to compose heterogeneous capabilities into a coherent whole. Counter-UAV defense is therefore best regarded as a multi-stage cooperative process that spans sensing, information transfer, decision coordination, and engagement, which is precisely the structure that a task-chain abstraction is intended to capture.

Task-chain modeling formalizes this cooperation by organizing distributed node capabilities into a goal-oriented closed-loop structure. Zhong et al. [6] formulate engagement-chain optimization for unmanned combat systems, characterizing system resilience through the observe-orient-decide-act loop and assessing link quality in terms of mission reward and post-interruption performance fluctuation. Liu et al. [7] construct engagement webs for heterogeneous UAV swarms, organizing nodes with diverse capabilities into several parallel engagement chains through a dynamic consensus-based coalition algorithm, and they emphasize that the way nodes are combined determines whether a mission remains closed in a contested and time-varying environment. Zheng and Yuan [16] jointly optimize sensor configuration and path planning, showing that the perception layout at the front of the chain governs the execution quality of the subsequent links. This line of work, however, treats a chain as stable once it is formed and gives little attention to how an executable closed loop can be re-established after defending nodes fail; taking an initial chain as given, this paper instead studies its reconfiguration under such failures.

2.2. Dynamic Multi-UAV Task Allocation

Building a task chain ultimately depends on matching resources to targets, a problem that counter-UAV studies typically formulate as resource-target allocation or dynamic weapon-target assignment. Representative methods address this matching through multi-agent reinforcement learning [17], improved grey wolf optimization [18], multi-objective particle swarm optimization [19], and Gaussian-mutation beetle swarm optimization [20], with each emphasizing a different balance between solution scale and dynamic adaptability. Although effective at the matching itself, these methods primarily optimize the binary relation of which resource engages which target, and they give limited attention to the cross-stage dependence among sensing, coordination, and engagement, as well as to the chain structure that this dependence induces.

At the broader level of multi-UAV task allocation, the central difficulty is the dynamic variation of tasks, platforms, and environmental states. The survey of Alqefari and Menai [4] identifies real-time requirements, task changes, platform state, communication constraints, and multi-objective optimization as the defining issues of the field. Xu et al. [5] address uncertain environments with a bi-objective dynamic cooperative assignment that uses a modified multi-objective evolutionary algorithm based on decomposition (MOEA/D) with heuristic initialization to jointly optimize mission reward and resource consumption; a centralized-versus-distributed comparison reveals the trade-off among global optimality, communication overhead, and response speed [21], and a hybrid scheme that combines clustering, optimization, and heuristic search improves dynamic adaptability [22]. To handle tasks that change during execution, hierarchical replanning revises the current plan while a formation is still executing it [23], and learning-based and search-based methods such as deep reinforcement learning, the wolf pack algorithm, Monte Carlo tree search, and generative allocation further extend the range of methods available for dynamic task allocation [24,25,26,27]. Although this line of work is methodologically rich, the optimization object remains the platform-task matching relation, and a change of state is typically handled by re-solving the allocation from scratch, without explicitly considering the inheritance of surviving links after a disturbance or the control of collateral changes to unaffected targets. It is precisely this requirement of inheritance and stability that distinguishes task-chain reconfiguration from general dynamic allocation.

2.3. Resilient Task-Chain Reconfiguration under Disturbance

The work most directly related to recovery after a disturbance is resilient task allocation, which concerns the ability of a system to sustain and restore task execution under node failure or capability degradation. Zeng et al. [28] combine task decomposition with resource allocation in a bilevel particle swarm optimization–integer linear programming (PSO-ILP) formulation that strengthens execution resilience for UAV swarms in complex and uncertain environments. Mayya et al. [29] introduce a capability model for heterogeneous multi-robot systems that characterizes how robots adapt to tasks under abnormal or degraded conditions. Neville et al. [30] interleave allocation, scheduling, and motion planning in D-ITAGS so that the plan can be adjusted online as task requirements and robot states evolve, while trait-based allocation and scheduling [31] and adaptive allocation under unknown and evolving capabilities [32] show that the capability model itself can change over time and must be kept feasible through continual updates.

Across these works, a common conclusion is that post-disturbance allocation should account for capability change, recovery cost, and the risk of interruption rather than be re-solved from scratch. Two aspects, however, remain under-addressed in counter-UAV settings: the closed-loop chain structure, in which a target requires both a sensing link and an engagement link while an optional coordination node introduces an effectiveness-delay trade-off, and the collateral change imposed on the still-intact links of unaffected targets, which recovery-only objectives rarely measure. Both aspects are addressed in this paper through a single reconfiguration model and a bi-objective formulation; because such reconfiguration is difficult to steer with hand-crafted rules across diverse node-loss patterns and chain types, the automated heuristic design described in the following subsection is adopted.

2.4. Large Language Model-Based Automated Heuristic Design

The goal of automated heuristic design is to reduce the reliance on manually designed rules in complex optimization tasks. Romera-Paredes et al. [10] propose FunSearch, which combines a large language model with a systematic evaluator to search for executable programs within a function space and discovers new heuristic structures for problems such as online bin packing. Liu et al. [8] propose Evolution of Heuristics, which represents a heuristic idea in natural language, translates it into code, and improves both the idea and the program through evolutionary search. Ye et al. [9] propose ReEvo, which introduces a reflection mechanism into heuristic evolution so that past search experience can influence later candidate generation. Research on heuristic evolution for multi-objective optimization further demonstrates that heuristics generated by a language model can handle multi-objective trade-offs [33].

Within more complex automated optimization frameworks, LLMOA uses a large language model as a high-level hyper-heuristic component to construct sequences of optimization operators [34], while autonomous multi-objective optimization uses a language model to design the algorithmic structure for solving multi-objective problems [35]. Chen et al. [36] propose AgentAD, a multi-agent language model framework that assigns generation, verification, and feedback roles to different agents for the automated design of algorithms in Earth observation satellite scheduling. LLaMEA further demonstrates that a language model can automatically generate black-box optimization metaheuristics through an evolutionary process [37]. In addition, studies on the importance of evolutionary search, on exploration guided by Monte Carlo tree search, and on neighborhood search driven by a language model improve the pipeline of automated heuristic design with respect to search pressure, space coverage, and the efficiency of neighborhood search [38,39,40]. These studies demonstrate that a language model can progress from generating answers to generating executable algorithmic structures. Existing automated heuristic design, however, primarily targets standard combinatorial or continuous optimization benchmarks and typically produces generic construction rules, local search operators, or metaheuristic pipelines. This paper differs by embedding automated heuristic design into cooperative counter-UAV task-chain reconfiguration, so that the generated object directly serves chain keeping, node replacement, chain-type switching, and reconfiguration-cost control after a disturbance.

3. Problem Definition

3.1. Task-Chain Representation and Baseline Plan

This section formalizes cooperative counter-UAV task-chain reconfiguration over a single decision period following a disturbance. The defense system comprises sensing, coordination, and engagement nodes, which are already organized into a baseline task-chain plan before the disturbance. When part of these nodes fail, the solver must rebuild the surviving plan subject to five classes of constraints, namely failed-node prohibition, reachability, capacity, chain integrity, and time windows. The reconstruction balances two competing objectives: maximizing the engagement effectiveness recovered by the new plan and minimizing its deviation from the baseline.

Let $\mathcal{S}$, $\mathcal{C}$, $\mathcal{I}$, and $\mathcal{U}$ denote the sets of sensing nodes, coordination nodes, engagement nodes, and intruding-UAV targets, respectively:

$$\mathcal{S}=\{1,\dots ,m\},\mathcal{C}=\{1,\dots ,h\},\mathcal{I}=\{1,\dots ,n\},\mathcal{U}=\{1,\dots ,l\}.$$

(1)

The spatial layout of the nodes, including position, coverage radius, and effective range, is summarized by the binary reachability parameters $a_{s,u}^S$, $a_{c,u}^C$, and $a_{i,u}^I$, where a value of one indicates that the corresponding link is physically reachable. On a reachable link, $q_{s,u}$ denotes the effective sensing probability of sensing node s for target u and $p_{i,u}$ the effective engagement probability of engagement node i for target u; both are set to zero on unreachable links. The response delays of the sensing, coordination, and engagement stages are denoted ${\tau }_s^S$, ${\tau }_{c,u}^C$, and ${\tau }_{i,u}^I$, respectively.

A candidate reconstructed plan is described by three classes of binary assignment variables:

$$x_{s,u},z_{c,u},y_{i,u}\in \{0,1\},X=(x,z,y),$$

(2)

where $x_{s,u}=1$, $z_{c,u}=1$, and $y_{i,u}=1$ indicate that sensing node s, coordination node c, and engagement node i are assigned to target u. Target u is regarded as activated once it receives at least one assignment from any node class:

$$r_u\left(X\right)=\mathbf{1}\left[\sum _{s\in \mathcal{S}}{x}_{s,u}+\sum _{c\in \mathcal{C}}{z}_{c,u}+\sum _{i\in \mathcal{I}}{y}_{i,u}>0\right].$$

(3)

Intruding UAVs differ in threat value and in how much delay they tolerate, so the model distinguishes two executable task chains. The sensing-engagement chain relays target information from a sensing node directly to an engagement node; its end-to-end delay is short, which makes it suitable for targets with tight time windows. The sensing-coordination-engagement chain inserts a coordination node that performs situation fusion and fire scheduling, introducing a target-level success-rate gain at the price of additional delay, and is therefore reserved for targets whose time windows can absorb that delay. The two chains differ only in whether target u is connected to a coordination node, a choice the solver makes from each target’s time window rather than fixing in advance by target class. In either case, an activated target must contain at least one sensing node and one engagement node so that its task chain forms a closed loop.

The success-rate gain introduced by the coordination stage is

$${\gamma }_u\left(z\right)=1+(g-1)\mathbf{1}\left[\sum _{c\in \mathcal{C}}{z}_{c,u}\ge 1\right],g>1,$$

(4)

where g is the coordination gain coefficient, so that ${\gamma }_u=g$ when target u connects to a coordination node and ${\gamma }_u=1$ otherwise.

The engagement effectiveness of a target is synthesized from the per-link probabilities along its task chains. On a reachable link, the kill probability of a single sensing-engagement chain $(s,i)$ against target u is

$${\theta }_{s,i,u}\left(z\right)=min\{q_{s,u}{p}_{i,u}{\gamma }_u\left(z\right),1\}.$$

(5)

When several chains act on target u simultaneously, and assuming the chains are independent, the combined engagement success probability of target u is one minus the product of the individual chain failure probabilities:

$$P_u\left(X\right)=1-\prod _{s\in \mathcal{S}}\prod _{i\in \mathcal{I}}{\left(1-{\theta }_{s,i,u}\left(z\right)\right)}^{x_{s,u}{y}_{i,u}}.$$

(6)

The end-to-end response time of target u aggregates the delays of its assigned nodes:

$$T_u\left(X\right)=\sum _{s\in \mathcal{S}}{\tau }_s^S{x}_{s,u}+\sum _{c\in \mathcal{C}}{\tau }_{c,u}^C{z}_{c,u}+\sum _{i\in \mathcal{I}}{\tau }_{i,u}^I{y}_{i,u}.$$

(7)

The baseline plan that precedes the disturbance is denoted

$$X^0=(x^0,z^0,y^0).$$

(8)

The baseline plan is an exogenous input to the reconfiguration problem and is not optimized jointly with the reconfiguration method. It is produced by a deterministic greedy task-chain constructor that respects all reachability, capacity, chain-integrity, and time-window constraints and assigns at least one sensing node and one engagement node to as many targets as possible. A target with a loose time window additionally connects to a coordination node to obtain the success-rate gain, whereas a target with a tight window retains a low-delay sensing-engagement chain. In the experiments that follow, sensing and engagement nodes have unit capacity, ${\kappa }_s^S={\kappa }_i^I=1$, and each coordination node has multi-target capacity ${\kappa }_c^C=\lceil l/h\rceil >1$, so that the baseline plan can supply one executable chain per target wherever the resources allow.

3.2. Disturbance Event and Reconfiguration State

A disturbance event specifies the defending nodes that leave service during the current period. In a low-altitude counter-UAV setting, a defending UAV may drop out of the cooperative loop through destruction by hostile fire, loss of communication under jamming, or depletion of onboard power; each of these is treated uniformly as a node failure. The event is written as

$$\Delta =({\mathcal{D}}^S,{\mathcal{D}}^C,{\mathcal{D}}^I),$$

(9)

where ${\mathcal{D}}^S$, ${\mathcal{D}}^C$, and ${\mathcal{D}}^I$ are the sets of failed sensing, coordination, and engagement nodes. Removing every baseline link that passes through a failed node leaves the still-usable surviving plan:

$$\begin{array}{cc}\hfill x_{s,u}^{\mathrm{surv}}& =x_{s,u}^0\mathbf{1}[s\notin {\mathcal{D}}^S],\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill z_{c,u}^{\mathrm{surv}}& =z_{c,u}^0\mathbf{1}[c\notin {\mathcal{D}}^C],\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill y_{i,u}^{\mathrm{surv}}& =y_{i,u}^0\mathbf{1}[i\notin {\mathcal{D}}^I].\hfill \end{array}$$

(12)

The targets whose baseline chain passes through a failed node form the affected set ${\mathcal{U}}^{\mathrm{aff}}$. Their closed loops are broken and must be rebuilt without the failed nodes, whereas the surviving links of the remaining targets are kept whenever possible. Both the recovery objective $F_A$ and the reconfiguration-cost objective $F_D$ are evaluated over the entire plan, as defined in Section 3.3; the set ${\mathcal{U}}^{\mathrm{aff}}$ serves only to delineate the scope of the disturbance and to steer the search toward the damaged links.

The reconstructed plan X is obtained from the surviving plan $X^{\mathrm{surv}}$ through five link-level reconfiguration actions, which form the basic operations of the solver and are listed in Table 1. Affected targets are rebuilt mainly by insertion, replacement, switching, and release, while the remaining targets are kept; every entry of X that departs from the baseline plan $X^0$ contributes to the reconfiguration cost $F_D$.

Table 2 summarizes the main symbols of the model.

3.3. Objective Functions

The reconfiguration problem optimizes two conflicting objectives; throughout, $v_u$ denotes the value (threat weight) of target u and $P_u\left(X\right)$ the engagement success probability of Equation (6).

The first objective is the recovery effectiveness $F_A$, defined as the value-weighted engagement effectiveness of the reconstructed plan over all targets, which drives the solver to restore overall engagement capability after node loss:

$$F_A\left(X\right)=\sum _{u\in \mathcal{U}}{v}_u{P}_u\left(X\right).$$

(13)

Because the links on failed nodes are forced to zero, the broken closed loops must be rebuilt from surviving nodes. Retaining only the surviving links gives a feasible lower bound on effectiveness, while the pre-disturbance value $F_A\left(X^0\right)$ marks the upper bound attained by full recovery; maximizing $F_A$ pushes the solution toward that upper bound.

The second objective is the reconfiguration cost $F_D$, the link-change distance between the reconstructed plan and the pre-disturbance baseline plan $X^0$. It discourages secondary changes to the existing plan and equals the number of entries in which the three assignment matrices differ from the baseline:

$$F_D\left(X\right)=\sum _{s\in \mathcal{S}}\sum _{u\in \mathcal{U}}\left|x_{s,u}-x_{s,u}^0\right|+\sum _{c\in \mathcal{C}}\sum _{u\in \mathcal{U}}\left|z_{c,u}-z_{c,u}^0\right|+\sum _{i\in \mathcal{I}}\sum _{u\in \mathcal{U}}\left|y_{i,u}-y_{i,u}^0\right|.$$

(14)

Counted at unit cost, $F_D$ covers both the links forced off on failed nodes and the links newly built or replaced during recovery, and therefore measures the collateral change that reconfiguration imposes on the existing plan. The reconfiguration problem is finally cast as a constrained bi-objective minimization:

$$min\mathbf{F}\left(X\right)=\left(-F_A\left(X\right),F_D\left(X\right)\right).$$

(15)

3.4. Constraints

A feasible reconstructed plan must satisfy several classes of constraints. First, all assignments on failed nodes are forced to zero:

$$\begin{array}{cc}\hfill x_{s,u}& =0,\forall s\in {\mathcal{D}}^S,\forall u\in \mathcal{U},\hfill \end{array}$$

(16)

$$\begin{array}{cc}\hfill z_{c,u}& =0,\forall c\in {\mathcal{D}}^C,\forall u\in \mathcal{U},\hfill \end{array}$$

(17)

$$\begin{array}{cc}\hfill y_{i,u}& =0,\forall i\in {\mathcal{D}}^I,\forall u\in \mathcal{U}.\hfill \end{array}$$

(18)

Second, every node-target assignment respects physical reachability:

$$\begin{array}{cc}\hfill x_{s,u}& \le a_{s,u}^S,\forall s,u,\hfill \end{array}$$

(19)

$$\begin{array}{cc}\hfill z_{c,u}& \le a_{c,u}^C,\forall c,u,\hfill \end{array}$$

(20)

$$\begin{array}{cc}\hfill y_{i,u}& \le a_{i,u}^I,\forall i,u.\hfill \end{array}$$

(21)

Third, the number of targets served by each node is bounded by its capacity:

$$\begin{array}{cc}\hfill \sum _{u\in \mathcal{U}}{x}_{s,u}& \le {\kappa }_s^S,\forall s\in \mathcal{S},\hfill \end{array}$$

(22)

$$\begin{array}{cc}\hfill \sum _{u\in \mathcal{U}}{z}_{c,u}& \le {\kappa }_c^C,\forall c\in \mathcal{C},\hfill \end{array}$$

(23)

$$\begin{array}{cc}\hfill \sum _{u\in \mathcal{U}}{y}_{i,u}& \le {\kappa }_i^I,\forall i\in \mathcal{I}.\hfill \end{array}$$

(24)

Fourth, each target connects to at most one coordination node, which is what separates the sensing-engagement chain from the sensing-coordination-engagement chain:

$$\sum _{c\in \mathcal{C}}{z}_{c,u}\le 1,\forall u\in \mathcal{U}.$$

(25)

Fifth, the reconfiguration follows a partial-recovery strategy: a target may remain inactive, but once it is activated it must include at least one sensing node and one engagement node so as to form an executable closed loop:

$$\begin{array}{cc}\hfill \sum _{s\in \mathcal{S}}{x}_{s,u}& \ge r_u\left(X\right),\forall u\in \mathcal{U},\hfill \end{array}$$

(26)

$$\begin{array}{cc}\hfill \sum _{i\in \mathcal{I}}{y}_{i,u}& \ge r_u\left(X\right),\forall u\in \mathcal{U}.\hfill \end{array}$$

(27)

Sixth, the end-to-end response time of every activated target must lie within its window:

$$T_u\left(X\right)\le W_u,\forall u\in \mathcal{U}\mathrm{s}.\mathrm{t}.r_u\left(X\right)=1.$$

(28)

Finally, an activated target must be engaged with sufficient certainty: its combined engagement success probability must reach the target’s kill threshold $P_u^{min}$ (specified in Section 5):

$$P_u\left(X\right)\ge P_u^{min},\forall u\in \mathcal{U}\mathrm{s}.\mathrm{t}.r_u\left(X\right)=1.$$

(29)

Taken together, the objectives and constraints above define a constrained bi-objective nonlinear integer program. The nonlinearity originates from the probabilistic effectiveness expression in Equation (6), while the combinatorial difficulty arises from the binary assignment of three heterogeneous node classes under the coupled chain-integrity and time-window requirements.

4. Method

4.1. Overview and Design Rationale

MAHE has a bilevel structure (Figure 1). The outer level is an LLM-driven evolutionary layer that maintains a population P of N heuristics; each individual is a heuristic package—an executable scoring program $\psi$, a one-sentence natural-language design note, and meta-information (parent origin, generating operator, and measured fitness). The inner level is the multi-objective reconfiguration solver of Section 4.7, which, steered by the scores of $\psi$, searches the surviving plan and returns an approximate Pareto front in the $(-F_A,F_D)$ space. The outer level never edits a reconfiguration plan directly; it evolves the scoring logic that guides the inner search. Because the inner solver, its constraint handling, and its evaluation rule are held fixed for every candidate, two heuristics are always compared in the same environment, so any difference in fitness is attributable to the heuristic alone.

A single LLM loop that both proposes and judges heuristics tends to drift: it repeats similar score formulas, wastes inner evaluations on code that does not run, and cannot tell whether a stall comes from a poor operator choice or an exhausted idea. MAHE therefore decomposes the outer level into four agents with disjoint, mutually constraining contracts, summarized in Table 3. The evolution agent proposes a candidate by applying one variation operator to selected parents; the coordinator agent decides which operator to apply, learning online which operators are currently productive; the repair agent fixes candidates that fail the static validator, so that only executable, interface-conformant code reaches the inner solver, and accumulates the failures it observes into a reusable memory; and the reflection agent diagnoses why the search has stalled and injects a corrective hint into later generation. Together they form a generate–validate–evaluate–reflect closed loop in which generation is adaptive rather than driven by a fixed operator rotation.

Algorithm 1 states the outer loop. After the population is seeded, each iteration draws an operator from the coordinator, lets the evolution agent generate a candidate from sampled parents, and passes it to the repair agent, which either makes it executable or rejects it. A surviving candidate is scored by the inner solver on the training scenarios; its realized improvement over the incumbent best updates the coordinator’s operator weights, and the population keeps the best N packages. A stall counter tracks consecutive non-improving evaluations, and when it reaches the patience $T_p$ the reflection agent fires and its diagnosis conditions the next generation. The loop runs until the evaluation budget B is spent, after which the best heuristic ${\psi }^{★}$ is deployed on the test scenarios at the full inner-solver budget. In the experiments $N=10$ and $B=100$.

Algorithm 1:MAHE outer loop (LLM-driven heuristic evolution).

Require: training scenarios $\mathcal{T}$; seed heuristic ${\psi }_0$; population size N; budget B; operator set $\mathcal{O}$; patience $T_p$ Ensure: best heuristic ${\psi }^{★}$ 1: $P\leftarrow InitPopulation({\psi }_0,N)$, each scored on $\mathcal{T}$ by the inner solver ▹ seed package + LLM-initialized packages 2: ${\omega }_o\leftarrow 1/\left|\mathcal{O}\right|\forall o\in \mathcal{O}$; $\mathcal{M}\leftarrow \varnothing$; $\xi \leftarrow none$; $c_{\mathrm{stall}}\leftarrow 0$; $b\leftarrow \left|P\right|$ 3: while$b<B$do 4:     $o\leftarrow SelectOperator\left(\left\{{\omega }_o\right\}\right)$▹ coordinator agent (operator bandit) 5:     $\psi \leftarrow Generate\left(o,Parents\left(P\right),\xi ,\mathcal{M}\right)$▹ evolution agent 6:     $(\psi ,\mathrm{ok})\leftarrow Repair(\psi ,\mathcal{M})$▹ repair agent, triggered by the validator; may grow $\mathcal{M}$ 7:     if $\neg \mathrm{ok}$ then 8:         $UpdateWeights(o,0)$; $c_{\mathrm{stall}}\leftarrow c_{\mathrm{stall}}+1$; continue 9:     end if 10:     score $\psi$ on $\mathcal{T}$ with the inner solver; $b\leftarrow b+1$ 11:     $r\leftarrow$ gain of $\psi$ in mean normalized hypervolume over the incumbent best ▹ operator reward 12:     $UpdateWeights(o,r)$▹ coordinator learns 13:     if $\psi$ improves the incumbent best then 14:         record the before/after packages; $c_{\mathrm{stall}}\leftarrow 0$; $\xi \leftarrow none$ 15:     else 16:         $c_{\mathrm{stall}}\leftarrow c_{\mathrm{stall}}+1$; append $\psi$ to the stalled set 17:     end if 18:     $P\leftarrow KeepBest(P\cup \{\psi \},N)$▹ rank by fitness; drop duplicates 19:     if $c_{\mathrm{stall}}\ge T_p$ then 20:         $\xi \leftarrow Reflect(\mathrm{before},\mathrm{after},\mathrm{stalled})$; $c_{\mathrm{stall}}\leftarrow 0$▹ reflection agent 21:     end if 22: end while 23: return the fittest ${\psi }^{★}$ in P

4.2. Heuristic Package and Reconfiguration Interface

Genotype. Each individual is a heuristic package: a one-sentence design note in natural language together with a Python program that implements a single scoring function $\psi$. The note is never executed—it carries the design intent into later generation prompts and reflections—whereas only the program couples to the inner solver. This separation lets the LLM reason about why a heuristic should work while the search rewards only what its code measurably achieves.

Phenotype interface. The program exposes a fixed signature, which is the sole coupling point between the outer evolution and the inner solver:

$$\psi \left(\Xi ,\Delta ,X^0\right)\to \left\{S^S\in {\mathbb{R}}^{m\times l},S^C\in {\mathbb{R}}^{h\times l},S^I\in {\mathbb{R}}^{n\times l},\mathbf{w}\in {\mathbb{R}}^3\right\}.$$

(30)

Here $\Xi$ gathers the instance parameters (node sets, reachability $a^S,a^C,a^I$, effective probabilities $q,p$, stage delays, capacities, target values, and time windows); the disturbance $\Delta$ enters as the per-class survival masks that flag the failed nodes ${\mathcal{D}}^S,{\mathcal{D}}^C,{\mathcal{D}}^I$; and $X^0$ is the pre-disturbance baseline plan. The entries $S_{s,u}^S$, $S_{c,u}^C$, and $S_{i,u}^I$ are priority scores for connecting a sensing, coordination, or engagement node to target u (higher means more preferred). The surviving plan $X^{\mathrm{surv}}$ and the affected set ${\mathcal{U}}^{\mathrm{aff}}$ of Section 3.2 are not passed separately, since both are recoverable inside $\psi$ from $X^0$ and the survival masks. The auxiliary vector $\mathbf{w}$ is a three-dimensional objective-bias term retained from the underlying solver interface; the reconfiguration search is steered entirely by the three score matrices, so $\mathbf{w}$ is validated for shape but not consumed.

Genotype-to-phenotype mapping. Unlike the static node-target score of generic task allocation, this interface makes the disturbance first-class. The survival masks push the scores of failed nodes out of contention; the baseline plan $X^0$ lets the heuristic distinguish a surviving link from a newly built one, and thus trade recovery against disturbance; and the discrepancy between $X^0$ and the survival masks reveals which targets have lost their closed loop and should be rebuilt first. A competent heuristic therefore raises the score of surviving, reachable nodes on broken chains and damps unnecessary changes elsewhere, balancing a high recovery effectiveness $F_A$ against a low reconfiguration distance $F_D$. The inner solver converts these scores into the five link-level actions of Table 1—keep, insert, replace, switch, release. The search is seeded with one hand-written heuristic that scores each node by value-weighted effectiveness per unit cost and delay, adds a bonus for links already present in $X^0$, and masks out failed or unreachable nodes; every other initial package is written from scratch by the evolution agent. The signature in Equation (30) is frozen for the whole run: evolution rewrites only the body of $\psi$, never the problem, the constraints, or the evaluation function.

4.3. Evolution Agent

The evolution agent realizes variation. Given an operator o chosen by the coordinator and one or two parents sampled from P, it assembles a prompt—the reconfiguration task description, the function specification of Equation (30), the parent package(s), the active reflection $\xi$, and the accumulated pitfalls $\mathcal{M}$—queries the LLM, and parses the reply into a new package: a brace-delimited design note followed by a fenced code block. Candidates whose code duplicates an existing package (by hash) are dropped. The operator pool $\mathcal{O}$ holds seven operators in three families, listed in Table 4: exploration ($E_1,E_2$) proposes structurally new heuristics for diversity; modification ($M_1,M_2,M_3$) refines a single parent; and ruin-and-recreate ($R_1,R_2$) deletes part of a parent and rebuilds it, escaping the parent’s local structure without discarding it wholesale. A separate initialization operator $I_1$ writes a heuristic from scratch and is used only to seed P. The five exploration and modification operators $E_1,E_2,M_1,M_2,M_3$ adopt the operator style of Evolution of Heuristics (EoH) [8], whereas the two ruin-and-recreate operators $R_1,R_2$ absorb the idea of LLM-driven neighborhood search [40], which repeatedly ruins and rebuilds part of a heuristic to explore its structural neighborhood. The full prompt templates—the shared task description and function specification, the initialization operator $I_1$, and the seven variation operators $E_1,E_2,M_1,M_2,M_3,R_1,R_2$—are reproduced in Appendix A (Figure A1–Figure A6).

Parents are sampled with probability proportional to $1/(r_i+1+N)$, where $r_i$ is the fitness rank of ${\psi }_i$ in P (rank 0 is best), which favors stronger heuristics without starving the tail; $E_1$ and $E_2$ draw two parents, the remaining operators one.

4.4. Coordinator Agent: An Operator Bandit

The coordinator decides which operator to apply, treating operator choice as a multi-armed bandit that replaces the fixed operator schedule of single-agent heuristic design. Each operator $o\in \mathcal{O}$ carries a weight ${\omega }_o$, initialized uniformly to $1/\left|\mathcal{O}\right|$. Operators are sampled from a distribution that mixes the normalized weights with a uniform exploration floor ${ϵ}_0$, in the style of Exp3:

$${\pi }_o={ϵ}_0+\left(1-\left|\mathcal{O}\right|{ϵ}_0\right){\displaystyle \frac{{\omega }_o}{{\sum }_{o^{\prime }\in \mathcal{O}}{\omega }_{o^{\prime }}}}.$$

(31)

Once the candidate produced by o has been scored, the coordinator forms a reward from the realized gain of that candidate over the current incumbent best heuristic, clipped to a bounded range,

$$r=\mathrm{clip}\left(\overline{HV}\left(\psi \right)-{\overline{HV}}^{\mathrm{best}},-c_r,c_r\right),$$

(32)

and updates the operator weight multiplicatively, after which the weights are renormalized:

$${\omega }_o\leftarrow {\omega }_{o}exp\left(\eta r\right).$$

(33)

Here $\overline{HV}\left(\psi \right)$ is the mean normalized hypervolume ($HV$) of $\psi$ over the training scenarios, $\eta$ is the learning rate, $c_r$ the reward clip, and ${ϵ}_0$ the exploration floor; the experiments use $\eta =2$, $c_r=0.5$, and ${ϵ}_0=0.02$. Operators that have recently yielded genuine gains are sampled more often, while the floor keeps every operator reachable, so the schedule tracks the shifting usefulness of operators over a run with no phase labels, diversity gates, or hand-set thresholds—a deliberately transparent controller governed by a single learning rate. Disabling this agent collapses operator choice to a deterministic round-robin over $\mathcal{O}$, which is the w/o coordinator ablation of Section 5.4.

4.5. Repair Agent: Accumulating Error Memory

Before a candidate can consume an inner evaluation, the repair agent guarantees that it is runnable and interface-conformant. A static validator compiles the code, executes $\psi$ on a probe instance, and checks that the result is a dictionary whose four arrays have exactly the shapes $m\times l$, $h\times l$, $n\times l$, and 3 and contain only finite values. If the validator reports an error, the agent enters a repair loop of at most $L_r$ attempts: at each attempt it asks the LLM for a minimal edit that corrects only the syntactic or interface fault while preserving the heuristic’s scoring logic, then re-validates; a candidate still invalid after $L_r$ attempts is rejected and counts as a zero-reward outcome for its operator. Crucially, every distinct failure is distilled by the LLM into a one-sentence root-cause lesson and accumulated into a persistent error memory $\mathcal{M}$. This memory is injected both into subsequent repair prompts and, as a known-pitfalls note (Appendix A), into the generation prompts of the evolution agent, so a recurring fault is progressively designed out at its source rather than only patched after the fact. Repair thus both rescues otherwise-discarded high-quality heuristics and steers future generation away from systematic interface mistakes. The experiments use $L_r=3$; disabling the agent—candidates that fail validation are discarded outright—gives the w/o repair ablation.

4.6. Reflection Agent: Patience-Triggered Diagnosis

The reflection agent supplies semantic, cross-generation guidance and—unlike a critic invoked at every step—fires only when the search is demonstrably stuck. A stall counter increments on each evaluation that fails to improve the incumbent best and resets on any improvement; when it reaches the patience $T_p$, reflection is triggered. The agent is shown the two heuristics that straddle the last effective improvement—the package before and the package after, each with its mean normalized hypervolume—together with the recent non-improving packages, and is asked to diagnose, in free text, why progress halted (for instance, structural redundancy, neglected survival or baseline-plan signals, or poor objective balancing) and what structural change might break the stall. The resulting diagnosis $\xi$ is prepended to the next generation prompt, biasing the LLM toward the indicated change, and is cleared as soon as a new improvement appears. Because reflection is gated by patience rather than issued every step, its extra LLM cost is paid only when deep diagnosis is actually warranted, and its effect is observable as a redirection of the operators that follow. The experiments use $T_p=5$; removing the agent yields the w/o reflection ablation. This division of labor draws on reflective heuristic evolution and multi-agent automated algorithm design [9,33,36,37], but here each agent’s generated object is confined to the scoring and repair logic of task-chain reconfiguration.

4.7. Inner Reconfiguration Solver

The inner solver is a constrained search in the $(-F_A,F_D)$ space in the style of the non-dominated sorting genetic algorithm II (NSGA-II) (Algorithm 2). It takes a disturbed scenario—the survival masks, the baseline plan $X^0$, and the instance parameters—together with the score matrices produced by $\psi$, and returns an approximate Pareto set. The same solver scores candidates during evolution and deploys the final heuristic; only its budget differs, being reduced while scoring candidates for speed and run at full size at deployment (Section 5.2.3).

Initialization. The population of K individuals is built half by heuristic guidance and half at random. A score-guided greedy constructor processes targets in descending order of value plus best attainable score and, for each target, draws a surviving, reachable, capacity-available sensing and engagement node by a softmax over $S^S$ and $S^I$, then attaches a coordination node when $S^C$ is competitive and the time window permits; small Gaussian perturbations of the scores diversify these individuals. The remaining individuals are random feasible solutions biased toward $X^0$. Coverage is never forced—a target that cannot be feasibly closed is left inactive—so partial recovery is available from the first generation.

Score-guided offspring. Each generation selects parents by binary tournament on non-domination rank, crowding distance, and constraint violation, applies uniform crossover to the three assignment matrices, and then perturbs the child with a score-guided bit flip: an inactive entry is switched on with a probability that rises with its normalized score, and an active entry is switched off with a probability that rises with one minus its score (perturbation strength $\beta \in [0.25,0.65]$). The heuristic thereby shapes both the initial solutions and the direction of search. Should $\psi$ raise an error at runtime or return invalid scores, the solver falls back to plain uniform crossover, so an occasional faulty heuristic degrades quality gracefully rather than crashing the evaluation.

Feasibility repair. Every child is then projected onto the feasible region of Section 3.4: links on failed or unreachable nodes are cleared; per-node assignments exceeding capacity are trimmed by score; each target is reduced to at most one coordination node; targets left with only a sensing or only an engagement link are deactivated; and links that push the response time past the window are removed, coordination first. At the link level these projections are the five reconfiguration actions of Table 1—keeping a surviving link, inserting a new one, replacing a failed or weak node, switching the chain type, and releasing an unrecoverable target—so the abstract action set and its executable realization coincide.

Selection and archive. Survivors are chosen by fast non-dominated sorting with crowding-distance truncation, and an external archive accumulates the running non-dominated set, truncated to $A_{max}$ by crowding distance on overflow. When the search ends, the first front of the archive is the heuristic’s Pareto set on that scenario. The evaluation rule, constraint handling, and archive policy are identical for every $\psi$; the heuristic influences only construction and offspring perturbation. This is precisely what makes the outer comparison fair: a difference in the returned front reflects the scoring logic, not the solver.

Algorithm 2:Heuristic-guided inner reconfiguration solver $InnerSolver(\mathrm{scn},\psi )$ on one scenario.

Require: scenario $\mathrm{scn}=(\mathrm{survival}\mathrm{masks},X^0,\Xi )$; heuristic $\psi$; population K; generations G; archive size $A_{max}$ Ensure: approximate Pareto set in the $(-F_A,F_D)$ space 1: $(S^S,S^C,S^I,\mathbf{w})\leftarrow \psi (\Xi ,\Delta ,X^0)$ 2: build $\lfloor K/2\rfloor$ individuals by score-guided greedy construction and the rest at random; repair all; evaluate $(-F_A,F_D)$ and constraint violation 3: $\mathcal{A}\leftarrow$ non-dominated individuals of the population 4: for$j=1$ to G do 5:     $\Pi \leftarrow$ binary-tournament parents on (rank, crowding distance, violation) 6:     for each parent pair in $\Pi$ do 7:         child ← uniform crossover, then score-guided bit flip with $S^S,S^C,S^I$▹ fallback: plain crossover if $\psi$ is invalid 8:         child ← feasibility repair ▹ keep / insert / replace / switch / release, Table 1 9:     end for 10:     population ← non-dominated sort with crowding truncation of $(\mathrm{population}\cup \mathrm{offspring})$ to K 11:     $\mathcal{A}\leftarrow$ crowding truncation of $nondominated(\mathcal{A}\cup \mathrm{offspring})$ to $A_{max}$ 12: end for 13: return first non-dominated front of $\mathcal{A}$

4.8. Outer-Level Fitness and Heuristic Selection

A candidate is scored by its average solution-set quality over the training scenarios $\mathcal{T}$—the four training instances under three disturbance ratios, so $\left|\mathcal{T}\right|=12$. On each scenario t, the inner front is mapped into the unit square against a fixed reference point precomputed from the baseline solvers (Section 5), and its normalized hypervolume ${\widehat{HV}}_t\left(\psi \right)\in [0,1]$ is measured; the per-heuristic quality is the mean

$$\overline{HV}\left(\psi \right)={\displaystyle \frac{1}{\left|\mathcal{T}\right|}}\sum _{t\in \mathcal{T}}{\widehat{HV}}_t\left(\psi \right).$$

(34)

Let ${\rho }_{\mathrm{feas}}\left(\psi \right)$ denote the fraction of training scenarios on which $\psi$ returns a non-empty front. The outer objective, which the population minimizes, couples quality with a hard feasibility gate:

$$J\left(\psi \right)=-\overline{HV}\left(\psi \right)+\lambda \mathbf{1}\left[{\rho }_{\mathrm{feas}}\left(\psi \right)<{\rho }^{★}\right]\left(1-{\rho }_{\mathrm{feas}}\left(\psi \right)\right),$$

(35)

where ${\rho }^{★}$ is the minimum acceptable feasibility and $\lambda$ a large penalty; the experiments use ${\rho }^{★}=0.5$ and $\lambda ={10}^6$. The indicator makes the penalty dominate $\overline{HV}$ whenever feasibility falls below ${\rho }^{★}$, so a heuristic that solves too few scenarios can never displace a feasible one however large its hypervolume on the rest, while above the gate the ranking is governed purely by solution-set quality. Scoring by hypervolume—rather than by a weighted sum of $F_A$ and $F_D$—keeps the recovery–disturbance trade-off explicit and prevents a single composite number from concealing it; the same $\overline{HV}\left(\psi \right)$ supplies the coordinator’s reward in Equation (32). When the budget B is spent, the incumbent best ${\psi }^{★}=arg{min}_{\psi }J\left(\psi \right)$ is deployed: it drives the inner solver, run at full population and generations, to report $HV$, $F_A$, and $F_D$ on each test scenario.

5. Experiments

5.1. Experimental Scenarios

The experiments address cooperative counter-UAV task-chain reconfiguration in a low-altitude area-protection setting. Each instance contains sensing, coordination, and engagement nodes together with a set of intruding-UAV targets, laid out so that coordination nodes occupy the rear, engagement nodes the middle, sensing nodes the front, and targets the side facing the intrusion. Sensing and engagement nodes have unit capacity, whereas a coordination node may serve several targets at the cost of an added delay. To assess generalization across scales, four training instances (T1–T4) were used for heuristic evolution and ten disjoint test instances (I1–I10), ranging from 8 to 320 targets, for the final comparison. The instance scales are listed in Table 5 and the attribute-generation rules in Table 6.

All attributes were drawn from the scale-independent distributions in Table 6, so instances differ only in size. For each instance, the baseline plan $X^0$ was built once by a deterministic greedy constructor: targets are processed in descending value order and assigned the best reachable, capacity-available sensing and engagement nodes, with a coordination node attached when the time window permits; full coverage is not enforced. A disturbance scenario then removed $\mathrm{round}(\alpha \times N_{\mathrm{class}})$ nodes (at least one) from the sensing, coordination, and engagement classes independently and uniformly at random, while the targets stayed fixed; the disturbance ratio $\alpha \in \{0.15,0.35,0.50\}$ models light, moderate, and heavy node loss. Disturbance scenarios were sampled with five random seeds (2021–2025): for each seed, one scenario was drawn per instance and ratio. The ten test instances under the three ratios therefore yield $10\times 3\times 5=150$ test scenarios for the comparison, while the four training instances supply the scenarios for heuristic evolution; the representative fronts and reconstruction reported below use seed 2021.

5.2. Experimental Setups

5.2.1. Experimental Platform Configuration

All experiments were conducted on a unified computing platform equipped with an Intel^® Core^™ Ultra 9 275HX CPU at 2.70 GHz and 32 GB of RAM, and all methods were implemented in Python 3.12. Each method was run once on every sampled scenario; because five independently seeded scenarios were drawn per instance and ratio, the reported values are the mean and standard deviation over the five seeds, after averaging each seed’s value over the three disturbance ratios.

5.2.2. Evaluation Metrics

Performance is measured by the normalized hypervolume $HV$ of the recovered solution set in the two-dimensional objective space $(-F_A,F_D)$, in which both objectives are minimized. To make the metric comparable across methods and across scenarios of very different scale, the hypervolume is measured against a common, data-driven reference rebuilt for each scenario rather than a hand-set point. For a given scenario, let $\mathcal{Q}$ be the union of the Pareto-front objective vectors produced by all compared methods, and let

$$z_k^{\mathrm{id}}=\underset{p\in \mathcal{Q}}{min}{p}_k,z_k^{\mathrm{nad}}=\underset{p\in \mathcal{Q}}{max}{p}_k,k\in \{1,2\},$$

(36)

be the component-wise ideal and nadir points, with $p=(-F_A,F_D)$. The reference point extends the nadir by a relative margin $\zeta =0.1$, and each objective vector is mapped into the unit box:

$$z_k^{\mathrm{ref}}=z_k^{\mathrm{nad}}+\zeta \left(z_k^{\mathrm{nad}}-z_k^{\mathrm{id}}\right),{\widehat{p}}_k=max\left(0,min\left(1,\frac{p_k-z_k^{\mathrm{id}}}{z_k^{\mathrm{ref}}-z_k^{\mathrm{id}}}\right)\right),$$

(37)

so that the normalized reference point is ${\widehat{z}}^{\mathrm{ref}}=(1,1)$. Denoting by $\widehat{\mathit{PF}}$ the non-dominated subset of a method’s normalized vectors, its normalized hypervolume is the area dominated within the unit square,

$$HV=\mathrm{\Lambda }\left(\bigcup _{\widehat{p}\in \widehat{\mathit{PF}}}[{\widehat{p}}_1,1]\times [{\widehat{p}}_2,1]\right)\in [0,1],$$

(38)

where $\mathrm{\Lambda }$ is the Lebesgue measure (area): $HV\to 1$ as the front approaches the ideal corner and $HV=0$ for an empty or fully dominated front, so a larger $HV$ reflects better convergence and spread at once. Statistical significance between MAHE and each competing method is assessed with a two-sided Wilcoxon signed-rank test on the per-scenario $HV$ of Equation (38), with Holm–Bonferroni correction across the comparisons.

5.2.3. Baseline Algorithms and Models

To evaluate the proposed method, MAHE is compared with baselines from distinct methodological categories, ranging from hand-crafted multi-objective solvers to recent language-model-based heuristic design, so that the comparison spans both numerical Pareto search and semantic heuristic generation:

• NSGA-II [41] and AGE-MOEA [42]: general-purpose multi-objective evolutionary algorithms that serve as basic references for population-based Pareto search. NSGA-II relies on fast non-dominated sorting and crowding distance, whereas AGE-MOEA replaces the crowding distance with a geometry-based survival score.
• MOEA/D-iAM2M [43] and adaptive large neighborhood search (ALNS) [44]: solvers more closely related to constrained resource-target assignment. MOEA/D-iAM2M is a decomposition-based method with dynamic subproblem assignment, and ALNS is a trajectory-based multi-objective variant that maintains an external non-dominated archive.
• EoH [8]: a representative LLM-based AHD method that evolves scoring heuristics with a single language-model agent, without the multi-agent coordination, repair, and reflection of MAHE. It serves as the direct AHD counterpart for isolating the benefit of the multi-agent design.

For a fair comparison of the language-model component, both AHD-based methods (EoH and MAHE) used the same large language model backbone, DeepSeek-V4-Flash, as the heuristic generator under identical decoding settings, so that any performance difference reflects the framework design rather than the underlying model. To isolate the effect of the candidate-generation strategy, all methods shared the same baseline plan $X^0$ and a comparable evaluation budget of about ${10}^4$ candidate evaluations: the population-based solvers ran 100 individuals for 100 generations, while ALNS performed 1665 iterations, each generating six candidate solutions that were evaluated once. EoH and MAHE additionally ran an outer heuristic-evolution loop with a heuristic population of 10 under a budget of 100 heuristic evaluations; their main configurations, together with the shared inner-solver settings used at deployment, are listed in Table 7.

5.3. Comparative Experiments

This subsection evaluates MAHE against the five baselines along two axes: the quality of the recovered solution set and its robustness to increasing node loss. For every test instance, the mean and standard deviation are reported over five independent test-scenario seeds (each value first averaged over the three disturbance ratios), with the best entry in each row shown in bold. The analysis proceeds from the aggregate hypervolume across all ten instances, whose differences are then confirmed by a pairwise statistical test, through the recovery–disturbance trade-off fronts at increasing node-loss ratios, to a single reconstruction instance that makes the recovered plan interpretable.

Table 8 reports the normalized $HV$ on the ten test instances, where a larger value indicates a better approximation of the $(-F_A,F_D)$ front in both convergence and spread; because the reference point is rebuilt for each scenario, values are comparable within a row but not across instances. Two patterns dominate. First, the two AHD-based methods outperform the four hand-crafted solvers by a wide margin, and the gap widens monotonically with scale. The hand-crafted solvers degrade steadily as the instance grows—NSGA-II, for example, falls from $0.856$ on the eight-target instance I1 to $0.287$ on the 320-target instance I10—and the group as a whole collapses from the $0.40$–$0.86$ band on I1 to the $0.26$–$0.36$ band on I10, whereas EoH and MAHE never drop below approximately $0.83$ at any scale. The two families are at near-parity on the smallest instance (MAHE within $0.007$ of the best solver on I1) but diverge sharply with size: on I10 the hand-crafted solvers occupy the $0.26$–$0.36$ band while MAHE attains $0.964$, a $2.7$- to $3.7$-fold gap. This indicates that a fixed operator set cannot keep the search inside the high-quality feasible region as the numbers of nodes and targets grow, whereas a generated, disturbance-specific heuristic preserves solution quality across scales. Among the hand-crafted solvers, MOEA/D-iAM2M is the weakest at every scale (mean $0.296$), suggesting that pure decomposition copes poorly with the tightly constrained, partial-recovery geometry of the reconfiguration front. Second, within the AHD family the multi-agent design of MAHE consistently surpasses the single-agent EoH: MAHE attains the best mean on nine of the ten instances and the highest overall mean ($0.949$ versus $0.906$). Its advantage is largest on the biggest instances (for example $0.964\pm 0.010$ versus $0.864\pm 0.054$ on I10) and—crucially—is accompanied there by a markedly smaller dispersion (std $0.010$ versus $0.054$), so MAHE is not only better on average but also more reliable run to run. We attribute this to the division of labor that EoH lacks: repair removes failed candidates before they consume inner evaluations, reflection re-targets generation when the search stalls, and adaptive scheduling keeps the operator mix matched to the search state, which together stabilize heuristic generation precisely where the single-agent loop becomes brittle. The sole exception is the smallest instance I1, on which NSGA-II already reaches a near-optimal front ($0.856$) and narrowly leads MAHE ($0.849$); when the feasible region is this small, a well-tuned population method suffices and the benefit of a generated heuristic has yet to emerge, yet even here MAHE stays within $0.007$ of the best.

All pairwise comparisons against MAHE are confirmed by a two-sided Wilcoxon signed-rank test and reported directly in Table 8. Over the pooled 150-scenario test MAHE is significantly better than every baseline ($p<0.001$, Holm–Bonferroni corrected), and the per-instance marks show that this advantage holds on essentially all medium and large instances; only on the smallest instances does the gap to the strongest competitors (notably NSGA-II and EoH) narrow to statistical parity, while the weaker solvers remain significantly behind throughout.

To expose the trade-off behind these hypervolumes, the recovery effectiveness $F_A$ and the reconfiguration distance $F_D$ are examined directly at the three disturbance ratios. Figure 2 overlays the fronts of all methods on instance I10 for a single representative run, with $F_A$ on the horizontal axis (larger is better) and $F_D$ on the vertical axis (smaller is better); a desirable front therefore lies toward the lower right, combining high recovery with a small change to the baseline plan. At light loss ($\alpha =0.15$), the hand-crafted solvers concentrate at low $F_A$ and elevated $F_D$, whereas MAHE simultaneously extends the front to the highest $F_A$ and presses $F_D$ to the lowest values, so that its front dominates those of the other methods; EoH also reaches high $F_A$, but its $F_D$ floor sits well above MAHE’s and its front remains dominated. As the loss grows to $\alpha =0.35$ and $\alpha =0.50$, the fronts of the classical solvers and ALNS steepen into a nearly vertical wall, so that additional recovery can be bought only at a sharply rising reconfiguration cost; MAHE instead keeps a low, wide, and almost flat front, sustaining high $F_A$ at a nearly constant $F_D$ and reaching recovery levels that the other methods attain only by paying a much larger $F_D$, if at all. EoH follows the same low-$F_D$ regime and clearly improves on the hand-crafted solvers, but its front is shorter and stays dominated by that of MAHE. The advantage of MAHE in the high-$F_A$, low-$F_D$ region is thus visible at every ratio and becomes more pronounced as node loss increases, mirroring the hypervolume trend in Table 8.

To make the reconfiguration behavior concrete, Figure 3 contrasts the baseline plan with the plan reconstructed by MAHE on instance I1 at $\alpha =0.35$ (representative seed 2021), a scenario in which the disturbance disables four of the twelve sensing nodes, one of the three coordination nodes, and four of the twelve engagement nodes, including a heavily used coordination hub. Every baseline chain routed through a failed node is severed, so that the affected targets lose their closed loops. MAHE repairs the plan by reusing the surviving links wherever feasible and rebuilding the broken chains through the five reconfiguration actions of keeping, insertion, replacement, switching, and release: the targets that depended on the failed coordination hub are rerouted onto the two surviving coordination nodes or switched to alternative sensing-engagement chains, while the unaffected targets are left untouched; targets that cannot be feasibly re-closed within their time windows remain inactive, realizing partial recovery. The reconstructed plan thus restores executable closed loops for the affected targets while altering only a small portion of the baseline plan, achieving a recovery effectiveness of $F_A=47.24$ at a reconfiguration distance of $F_D=12$—a single-scenario realization of the high-recovery, low-disturbance balance that the learned scoring heuristic is designed to strike.

5.4. Ablation Studies

To quantify the contribution of each agent, MAHE is compared with three variants that disable one mechanism at a time: w/o coordinator (the improvement-driven operator weighting is replaced by non-adaptive selection), w/o reflection (no cross-generation feedback), and w/o repair (invalid candidates are discarded instead of repaired). All variants share the full method’s budget, operator pool, training instances, and test-scenario seeds, and are scored by the same normalized $HV$ under the same six-method reference as the main comparison, so that Table 9 isolates the effect of coordination, reflection, and repair.

Removing any single mechanism lowers the mean normalized $HV$ below that of the full method ($0.949$), confirming that the three agents are complementary rather than redundant. Reflection is the dominant contributor: it accounts for the largest mean drop (to $0.869$, $-0.080$), and its effect is strongly scale-dependent—negligible to moderate on the small instances (I2–I4 remain at or above $0.92$) but severe on the large ones, where the variant falls into the $0.76$–$0.88$ band (on I10 the normalized $HV$ drops from $0.964$ to $0.765$). Cross-generation feedback is therefore what sustains progress as the reconfiguration space expands and a single generation can no longer reach good heuristics by chance. Repair is the second contributor (mean $0.919$, $-0.030$), with its effect again concentrated on the harder, more tightly constrained instances ($0.964$ versus $0.895$ on I10); correcting infeasible candidates instead of discarding them retains high-quality heuristics that the validation filter would otherwise throw away, which matters most where feasible heuristics are scarce. The coordinator contributes the least on average (mean $0.928$, $-0.021$), but its benefit is strongly scale-dependent: on the small instances a fixed round-robin operator schedule matches or marginally edges the full method (I1 and I4), whereas on the large instances the gap widens sharply ($0.964$ versus $0.871$ on I10 and $0.968$ versus $0.920$ on I9). Because the seven-operator pool is rich and complementary, non-adaptive selection suffices when the search space is small, but improvement-driven operator weighting becomes increasingly important as the reconfiguration problem grows—mirroring the scale dependence observed for reflection and repair. Over all 150 paired scenarios the full method significantly outperforms each variant (two-sided Wilcoxon signed-rank, $p<0.001$, Holm–Bonferroni corrected; reported directly in Table 9); the per-instance tests further show that each component’s contribution, though negligible on the smallest instances, becomes statistically significant on the larger ones.

Figure 4 plots the best-so-far outer-level fitness against the number of heuristic evaluations and reveals how each mechanism shapes the search trajectory. The full method climbs in a steady, stepwise fashion and is still improving when the budget is exhausted; its late surge over the final evaluations shows that the search has not yet saturated and that the complete framework keeps the heuristic evolving throughout training. The w/o-reflection variant, by contrast, advances in long plateaus and remains the lowest trajectory for almost the entire run, visually confirming that cross-generation feedback is what breaks stagnation and sustains progress. The w/o-repair variant exhibits the clearest signature of overfitting: it surges within the first handful of evaluations to the highest training fitness of any variant (final $0.928$, even above the full method’s $0.924$) and then stays essentially flat for the remainder of the budget, with no further gains. Crucially, this early training advantage does not carry over to unseen scenarios—at test time the variant falls behind the full method (cf. Table 9)—indicating that, without repair, the search locks onto a small set of heuristics that fit the few training scenarios but generalize poorly. Taken together, these trajectories show that it is the complete framework that keeps the heuristic evolving across the whole training budget while remaining generalizable: reflection and repair are decisive for both convergence and generalization, while the coordinator—whose w/o-coordinator curve reaches $0.901$ in training only via a single late jump—accelerates and stabilizes the search, its benefit on the final solution concentrated on the larger instances (Table 9).

6. Conclusions

This paper addressed the dynamic reconfiguration of cooperative counter-UAV task chains, the problem of restoring executable sensing-coordination-engagement loops after defending nodes fail. By taking intruding UAVs as target nodes and defending platforms as fixed-role functional nodes, and by inheriting the surviving plan rather than re-solving from scratch, the formulation places the task-chain structure, the inheritance of the historical plan, and the recovery–disturbance trade-off at its center, which distinguishes it from conventional task allocation. The problem was cast as a constrained bi-objective program over the recovered effectiveness and the reconfiguration cost, and solved by MAHE, an LLM-driven multi-agent framework that evolves reconfiguration-specific scoring heuristics for a fixed multi-objective solver.

The experiments support three conclusions. First, generated, disturbance-conditioned heuristics scale where fixed operator sets do not: across instances from 8 to 320 targets, MAHE maintained a consistently high solution quality, whereas the hand-crafted multi-objective solvers lost most of theirs as the problem grew, and the gap widened monotonically with scale. Second, the multi-agent decomposition is what delivers this behavior: against an otherwise comparable single-agent design, MAHE was both more effective and markedly more stable on the largest instances, and the ablation attributes the improvement to complementary roles—reflection breaking stagnation, repair retaining feasible high-quality heuristics, and adaptive operator scheduling tracking the search state—whose individual contributions grew with problem size. Third, the recovered plans realize the intended balance, sustaining high recovery at a nearly constant change to the baseline plan even under heavy node loss. Together these results indicate that automated, reconfiguration-oriented heuristic design is a scalable and reliable route to dynamic, heterogeneous, and constraint-intensive counter-UAV task planning.

7. Future Work

Several directions remain open. First, the present model reconfigures over a single decision period; extending it to multi-stage rolling reconfiguration would capture continuous node losses and successive waves of intruding targets, and would let the recovery–disturbance trade-off be optimized over a horizon rather than a single step. Second, the defending UAVs are assigned fixed roles; allowing their sensing, relay, and engagement functions to switch adaptively with payload and energy state would enlarge the reconfiguration action space and better reflect mobile platforms. Third, incorporating trajectory prediction and explicit uncertainty modeling would let reconfiguration anticipate the motion of intruding UAVs and act before, rather than after, a chain is broken. Fourth, under appropriate safety and compliance constraints, validation through hardware-in-the-loop simulation or real flight data would test the model’s applicability in operational low-altitude security settings. Pursuing these directions would extend the framework from single-shot recovery toward continuous, predictive, and field-validated counter-UAV task planning.

Appendix A.1. Task Description and Function Specification

Figure A1. Task description (_TASK_DESCRIPTION).

Figure A1. Task description (_TASK_DESCRIPTION).

Figure A2. Function specification (_FUNC_SPEC).

Figure A2. Function specification (_FUNC_SPEC).

Appendix A.2. Initialization and Variation Operators

Figure A3. Initialization operator $I_1$.

Figure A3. Initialization operator $I_1$.

Figure A4. Exploration operators $E_1$ and $E_2$.

Figure A4. Exploration operators $E_1$ and $E_2$.

Figure A5. Modification operators $M_1$, $M_2$, and $M_3$.

Figure A5. Modification operators $M_1$, $M_2$, and $M_3$.

Figure A6. Ruin-and-recreate operators $R_1$ and $R_2$.

Figure A6. Ruin-and-recreate operators $R_1$ and $R_2$.