A Generative Task Allocation Method for Heterogeneous UAV Swarms Empowered by Heterogeneous Toolchains

Highlights

What are the main findings?

• We proposed a generative task allocation paradigm augmented by a heterogeneous toolchain; it employs a dual-model architecture to transform UAV swarm task allocation from numerical fitting into semantic reasoning-based scheme generation, effectively suppressing the physical hallucinations and computational deficiencies of large language models.
• An execution-manifold-anchored orthogonal evolution training method and a Recursive Causal Probe algorithm are developed to resolve heterogeneous gradient conflicts and the credit assignment problem in long-horizon game scenarios through a temporal decoupling mechanism and counterfactual deduction.

What are the implications of the main findings?

• The proposed method achieves an 82.34% mission success rate with only 2.69 average interactive turns, significantly outperforming traditional methods in complex adversarial scenarios.
• The paradigm provides a promising technical pathway for mapping unstructured command intents to physically consistent tactical execution, offering a foundation for exploring broader multi-agent collaborative planning domains.

Abstract

Task allocation for heterogeneous unmanned aerial vehicle (UAV) swarms requires complex spatiotemporal coordination. While traditional algorithms struggle to interpret abstract semantic intents, general large language models (LLMs) often suffer from physical hallucinations and superficial tactical reasoning. To address these limitations, we propose a generative task allocation paradigm augmented by a heterogeneous toolchain, shifting the approach from rigid numerical optimization toward tool-grounded semantic planning. To implement this and overcome domain data scarcity, we design a decoupled dual-model architecture. This architecture is optimized through an execution-manifold-anchored orthogonal evolution training method. By utilizing simulated self-play within a stable execution environment, this approach prevents gradient conflicts and autonomously generates abundant training data. Furthermore, to resolve the credit assignment problem in long-horizon scenarios, we develop a Recursive Causal Probe (RCP) algorithm. By tracing failures backward through the simulation, RCP synthesizes counterfactual preference data, effectively translating tactical mistakes into precise corrections for the planning model. Extensive simulations demonstrate that our method achieves an 82.34% mission success rate in complex scenarios, requiring significantly fewer interactive corrections than general LLMs, fully verifying its physical feasibility and practical robustness.

1. Introduction

With the rapid development of unmanned aerial vehicle (UAV) technology, heterogeneous UAV swarms, which offer synergistic capabilities in payload and operational range, are increasingly applied in fields such as modern warfare, disaster rescue, and logistics transportation [1,2,3,4,5]. However, multi-UAV collaborative task allocation is fundamentally an NP-hard combinatorial optimization problem. Existing research primarily falls into three main categories: traditional optimization algorithms, deep reinforcement learning (DRL), and emerging large language models (LLMs).

Traditional optimization algorithms mainly include heuristics and meta-heuristics. Heuristic algorithms focus on designing efficient rules: Samiei et al. [6] proposed a clustering-based Hungarian algorithm, effectively reducing the computational complexity of large-scale multi-task allocation; Li et al. [7] introduced an overlapping coalition formation game framework and designed mechanisms for resource adjustment and invalid coalition exit, solving the collaboration problem under discrete resource constraints; and Liu et al. [8] constructed a dynamic coalition model oriented towards sequential task chains to address the challenges of sequential coordination in complex environments. Meta-heuristic algorithms aim to enhance global search capabilities: Zhang et al. [9] and Ye et al. [10] utilized an improved co-evolutionary particle swarm optimization and an adaptive genetic algorithm, respectively, to address the highly coupled nature of task allocation in heterogeneous swarms; Xiong et al. [11] constructed a gridded PSO-GA hybrid strategy (GrEAPSO) to balance exploitation and exploration. Furthermore, targeting high-dimensional multi-task scenarios, Dong et al. [12] proposed a joint optimization framework for task allocation and trajectory planning, achieving Pareto optimality under multi-dimensional constraints. Although these methods perform excellently in the numerical space, their computational overhead increases exponentially with scale, and they cannot interpret tactical intents formulated in natural language, resulting in inflexible execution.

DRL algorithms have shown tremendous potential in various UAV task planning scenarios due to their end-to-end decision-making capabilities [13,14,15,16]. To address the exponential growth of the state space in large-scale swarms, Zuo et al. [17] utilized an attention mechanism to rapidly capture swarm features; for complex SEAD (Suppression of Enemy Air Defenses) tasks, Yue et al. [18] constructed a hierarchical multi-agent framework to decouple target allocation from low-level coordination; Yin et al. [19] designed a deep transfer reinforcement learning algorithm based on QMIX, significantly accelerating model convergence. However, DRL methods suffer from severe cold-start issues and limited generalization capabilities, often failing catastrophically when encountering unforeseen commands or heterogeneous tasks.

The explosive growth of LLMs [20,21,22,23] has made their integration into UAV task planning a prominent research frontier. Recent surveys by Tian et al. [24] and Jin et al. [25] highlight this paradigm shift. They reveal a key insight: while LLMs excel in semantic reasoning, a fundamental gap remains in coupling this reasoning with structured optimization and physical control. Early explorations mainly focused on intent translation and logical decomposition. For instance, Cui et al. [26] mapped abstract language into executable Python code using the TPML framework. Similarly, Li et al. [27] utilized Chain of Thought (CoT) to decompose complex swarm tasks. However, pure LLMs often suffer from severe physical hallucinations when directly generating solutions. To mitigate this, Yu et al. [28,29] introduced external feasibility checkers and dual-verification mechanisms to ensure planning safety.

Tool-augmented AI architectures naturally help align semantic reasoning with physical constraints. As Xu et al. [30] highlighted, equipping LLMs with external tools significantly reduces computational errors and hallucinations. Advancing this concept in the UAV domain, Koubaa and Gabr [31] proposed the Agentic UAV framework. This fuses LLM reasoning with tool-calling interfaces, noticeably improving dynamic task allocation and detection confidence. Furthermore, Zhang et al. [32] introduced AFlow to optimize complex, multi-step tool invocations. They demonstrated that automating tool-use workflows over computational graphs greatly enhances both reasoning efficiency and task performance.

Despite their potential in zero-shot generalization and high-level mission decomposition, directly applying LLMs to physical domains remains difficult. Specifically, existing pure LLM and early tool-augmented methods still struggle with three fundamental issues in tactical environments:

• Computational and Physical Disconnect: LLMs lack native numerical and spatial reasoning skills. As a result, they struggle with strict resource and kinematic constraints, frequently generating physically impossible flight paths or payload plans.
• Gradient Conflicts and Data Scarcity: Forcing a single LLM to simultaneously learn abstract tactics and rigid tool syntax often leads to optimization conflicts. Combined with the severe lack of high-quality tactical data, this causes major cold-start issues.
• Lack of Deep Tactical Verification: Current LLM feedback loops usually rely on basic syntax or collision checks. They lack the deep, simulation-based feedback needed to correctly assign credit and optimize long-horizon tactics.

To address these limitations, we introduce a generative UAV task allocation paradigm augmented by a heterogeneous toolchain. We tackle the above issues through three structural innovations:

• Heterogeneous Toolchain Integration: We ground semantic generation in physical reality by integrating five types of tools. Specifically, the Excellent Case Retrieval and Knowledge Graph Query tools supply tactical priors and accurate equipment parameters to prevent hallucinations; the Geospatial Calculator and Risk-Cost Calculator provide exact spatial matrices and operational assessments; and the Simulation Evaluation tool offers closed-loop environmental feedback. Together, these tools translate abstract reasoning into executable, constraint-compliant UAV assignments.
• Decoupled Dual-Model Training: To prevent optimization conflicts, we design an execution-manifold-anchored orthogonal evolution training method. By separating the planning model (focused on intent) from the execution model (focused on syntax), we eliminate parameter interference. Furthermore, simulating self-play within a stable execution environment generates high-quality training data, directly overcoming the lack of domain data.
• Recursive Causal Probe: We develop a dynamic decision attribution algorithm to solve the credit assignment problem in long-horizon games. Through simulation-based backward tracing, RCP isolates the exact decision responsible for a mission failure. This translates sparse failure signals into dense, actionable feedback, ensuring the generated plans are both logically sound and practically viable.

Compared with existing hybrid planning frameworks, the main contributions of this paper are summarized as follows:

1.

A generative task allocation paradigm augmented by a heterogeneous toolchain. Unlike existing hybrid frameworks that rely on post-generation feasibility checks, this paradigm integrates a heterogeneous toolchain directly into the semantic reasoning loop. This effectively narrows the semantic–physical divide and translates abstract intents into executable plans, mitigating physical hallucinations.

2.

An execution-manifold-anchored orthogonal evolution training method. To alleviate optimization conflicts between abstract reasoning and tool syntax in monolithic models, this method adopts a decoupled dual-model architecture. It minimizes parameter interference and leverages self-play to synthesize high-fidelity data, mitigating domain data scarcity.

3.

A dynamic decision attribution algorithm based on the RCP. To address the complex credit assignment problem, RCP utilizes simulation-based backward tracing. It aims to translate sparse failure signals into actionable corrections, supporting the continuous improvement of the swarm’s tactical decision-making.

The remainder of this paper is organized as follows: Section 2 presents the mathematical model for heterogeneous UAV task allocation. Section 3 details the generative allocation paradigm augmented by the heterogeneous toolchain, the orthogonal evolution training method, and the RCP algorithm. Section 4 presents the simulation setups and results, verifying the effectiveness of the proposed methods. Finally, Section 5 concludes the paper.

2. Task Description and Modeling

Traditional numerical optimization paradigms based on Mixed-Integer Linear Programming (MILP) [33,34] struggle to process ambiguous command intents and unstructured tactical logic on the battlefield. To this end, this paper proposes a generative allocation paradigm augmented by a heterogeneous toolchain, which reconstructs the task allocation for heterogeneous UAV swarms into a problem of hierarchical intent-driven sequential decision-making and black-box constraint solving.

2.1. Task Description

This paper constructs a typical 3D Red-Blue adversarial task allocation scenario, as illustrated in Figure 1. The Red Force constitutes our heterogeneous UAV strike swarm, whereas the Blue Force comprises the enemy’s heterogeneous ground defenses and high-value targets.

• Red Force entities: This consists of five categories of heterogeneous UAVs: reconnaissance, attack, electronic warfare (EW), anti-radiation, and suicide UAVs. Each unit is defined by a multi-dimensional attribute vector, encompassing payload capabilities (e.g., hard-kill missiles), kinematic parameters (e.g., operational range and velocity), and inherent attributes (e.g., radar cross-section and RCS).
• Blue Force entities: This encompasses five types of ground facilities: radar stations, air defense missile silos, command centers, armored vehicles, and laser weapons. Each target possesses a specific defensive threat level and inherent attributes, and is assigned a distinct strike priority based on the dynamic battlefield situation.
• Planning objectives: Under the premise of satisfying payload limits and heterogeneous capability constraints, the system must adaptively allocate limited resources to the targets. The optimization process adheres to an intent-driven hierarchical logic:

  –

  Maximization of tactical effectiveness: Strictly align with the commander’s intent, prioritizing the guarantee of complete destruction or suppression of high-priority targets.

  –

  Minimization of operational costs: Based on mission completion, minimize fuel consumption, ammunition expenditure, and the expected combat attrition of the Red Force as much as possible.

2.2. Task Allocation Modeling

We define the battlefield situation $\mathcal{S}$ as a multimodal triplet $\mathcal{S}=({\mathcal{U}}_{red},{\mathcal{M}}_{red},{\mathcal{T}}_{blue})$, encompassing the Red Force heterogeneous UAV swarm (including types, positions, and quantities), the Red Force available missile inventory (including types and quantities), and the Blue Force heterogeneous target set (including types, positions, and quantities).

In response to the unstructured natural language instruction $\mathcal{I}$ input by the commander, this paper discards external rule engines and models it as a latent variable disentanglement task for the tactical planning model. Through the reasoning of the initial CoT, the model collapses the unstructured natural language instruction $\mathcal{I}$ into two core control variables:

$$(P_{mode},T_{scenario})\sim P\left(c_{init}\right|\mathcal{I},\mathcal{S};\varphi )$$

(1)

where $c_{init}$ denotes the initial reasoning sequence generated by the model and $\varphi$ represents the parameters of the tactical planning model.

These two variables define the optimization surface and topological boundary of the subsequent planning, respectively:

• Implicit Preference State $P_{mode}$: The value ranges over $\{Survival,Economic,Offensive,Balanced\}$. As a prior preference field, this state guides the generated schemes to shift towards specific evaluation regions by adjusting the weight space of multi-objective optimization.
• Explicit Tactical Scenario $T_{scenario}$: Defines the macroscopic tactical background of the current mission;

  Table 1. Description of mission scenarios.

  Scenario	Explanation
  Total Strike	Aims to maximally destroy all enemy combat capabilities and effective strength.
  SEAD	Prioritizes the destruction of radars and air defense missile sites to open safe corridors for subsequent echelons.
  Strategic Paralysis	Focuses on communication base stations, energy facilities, and airports to paralyze enemy operational capabilities.
  Armored Vehicle Annihilation	Targets enemy tank and armored vehicle clusters with intensive fire coverage.
  Decapitation Strike	Precisely locates and destroys enemy command posts or high-value leadership targets with minimal cost.

  illustrates the specific types of tactical scenarios. Serving as a soft constraint, it activates tactical meta-rules to guide target screening and resource allocation.

After establishing the battlefield situation $\mathcal{S}$ and logical constraints $(P_{mode},T_{scenario})$, this paper models the task allocation scheme as a Markov Decision Process (MDP) generated by the interaction between the semantic reasoning space and the physical execution manifold.

We define the joint interaction tuple at step t as $(c_t,i_t,a_t,o_t)$:

• $c_t$ (Chain of Thought): The tactical thinking process generated by the planning model, responsible for logical deduction.
• $i_t$ (Instruction): The specific tactical instruction issued by the planning model to the execution model.
• $a_t$ (Action): The specific tool invocation command.
• $o_t$ (Observation): The execution result returned by the tool.

To find the optimal policy ${\pi }^{\mathsf{\ast }}$, we perform orthogonal decomposition on the joint probability distribution of the trajectory $P\left(\tau \right|\mathcal{S},\mathcal{I})$ induced by the total historical context $H_{<t}$:

$$P\left(\tau \right|\mathcal{S},\mathcal{I})=\prod _{t=1}^T\underset{\mathrm{Tactical}\mathrm{Planner}{\pi }_{\varphi }}{\underbrace{P(c_t,i_t|H_{<t},\mathcal{S},\mathcal{I};\varphi )}}·\underset{\mathrm{Manifold}\mathrm{Executor}{\pi }_{\theta }}{\underbrace{P\left(a_t\right|i_t;\theta )}}$$

(2)

This architecture achieves the complete physical decoupling of cognition and execution:

• Tactical Planner Policy ${\pi }_{\varphi }$: Driven by parameters $\varphi$, it operates in the semantic space, focusing on processing complex tactical logical deductions and issuing intermediate instructions.
• Manifold Executor Policy ${\pi }_{\theta }$: Driven by parameters $\theta$, it is responsible for deterministically anchoring the unstructured instructions into legal tool actions.

Theoretically, while the factorization in Equation (2) shares the goal of external tool integration seen in recent agentic frameworks (e.g., MUTP-LLM [29] and Agentic UAVs [31]), our approach differentiates itself through its architectural mapping. Existing tool-augmented systems often rely on a monolithic LLM to simultaneously execute abstract semantic reasoning and generate rigid API syntax. In contrast, our orthogonal decomposition introduces two key theoretical advantages. First, it promotes optimization stability via gradient decoupling. Isolating parameters $\varphi$ and $\theta$ effectively mitigates the heterogeneous gradient interference and helps avoid the catastrophic forgetting of tactical logic that frequently challenges single-model tool learning [30]. Second, it enhances sample efficiency through dimensionality reduction. By acting as a deterministic bottleneck, the executor ${\pi }_{\theta }$ shields the planner from complex low-level schemas (unlike direct code-generation approaches such as TPML [26]), substantially compressing the effective action space. Ultimately, these decoupled policies leverage environmental observations $o_t$ to achieve robust closed-loop self-iteration, allowing ${\pi }_{\varphi }$ to focus primarily on high-level tactical alignment while alleviating the cognitive overload associated with end-to-end monolithic generation.

We define the final task allocation problem as a black-box constraint-solving problem based on simulation feedback. The complete task allocation scheme generated by the dual-model architecture, denoted as $\mathcal{T}$, after wargaming in the high-fidelity simulation environment $\mathcal{E}$, yields the final evaluation result R, which is calculated by the total effectiveness function J:

$$R=J\left(\mathcal{E}\left(\mathcal{T}\right)\right|P_{mode})$$

(3)

The solving objective of this method aims to find a valid scheme satisfying the tactical success threshold $\delta$:

$$\mathrm{find}\mathcal{T}\sim ({\pi }_{\varphi },{\pi }_{\theta })\mathrm{s}.\mathrm{t}.R\ge \delta$$

(4)

If $R<\delta$, the simulation feedback containing specific penalty items will be fed back as correction prompts to the planning model ${\pi }_{\varphi }$, triggering closed-loop iterative correction until the scheme meets the standard.

2.3. Effectiveness Evaluation Model

To transform unstructured tactical intents into quantifiable mathematical optimization objectives, this paper constructs a dynamic effectiveness evaluation model based on the S-E-O (Survival–Economic–Offensive) three-dimensional framework.

2.3.1. S-E-O Evaluation Metrics

This paper defines the simulation evaluation metrics from three orthogonal dimensions: offensive, survival, and economic.

(1)

O: Offensive Score

This dimension employs a time-effectiveness coupled model. Let ${\mathcal{T}}_{target}$ be the set of predetermined targets, ${\mathcal{T}}_{hit}$ be the set of actually destroyed targets, and $\tau$ and ${\tau }_{max}$ be the actual elapsed time and the maximum time limit, respectively. It is defined as:

$$O={\eta }_{task}·\left[{\gamma }_{base}+(1-{\gamma }_{base})·{\eta }_{time}\right]$$

(5)

where ${\eta }_{task}=|{\mathcal{T}}_{hit}|/|{\mathcal{T}}_{target}|$ is the task completion rate; ${\eta }_{time}=1-\tau /{\tau }_{max}$ is the time efficiency factor. This formula adjusts the time sensitivity via ${\gamma }_{base}$, balancing the tactical value of strike coverage and rapid resolution.

(2)

S: Survival Score

This dimension measures the battlefield survival rate of non-consumable units. To isolate expected tactical consumption, the set of suicide UAVs ${\mathcal{U}}_{suicide}$ is explicitly excluded. Let ${\mathcal{U}}_{total}$ and ${\mathcal{U}}_{alive}$ be the sets of Red Force units at the initial and final stages, respectively.

$$S=\left\{\begin{array}{cc}1.0,\hfill & \mathrm{if}|{\mathcal{U}}_{total}\setminus {\mathcal{U}}_{suicide}|=0\hfill \\ {\displaystyle \frac{|{\mathcal{U}}_{alive}\setminus {\mathcal{U}}_{suicide}|}{|{\mathcal{U}}_{total}\setminus {\mathcal{U}}_{suicide}|}},\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(6)

This design guides the model to focus on the battlefield survival performance of high-value reconnaissance or strike platforms.

(3)

E: Economic Score

This dimension measures the combat return on investment. To prevent reward explosion caused by extreme values, a Tanh mapping is utilized to compress values with a wide dynamic range into a normalized interval $[0,1]$. It is defined as:

$$E=tanh\left({\displaystyle \frac{V_{damage}}{C_{loss}+C_{ammo}}}·{\displaystyle \frac{1}{{\rho }_{sat}}}\right)$$

(7)

where $V_{damage}$ is the value of the damaged Blue Force targets, and $C_{loss}$ and $C_{ammo}$ are the battle loss and ammunition cost of the Red Force, respectively. ${\rho }_{sat}$ is the saturation threshold for the cost-effectiveness ratio.

2.3.2. Intent-Driven Effectiveness Function

To transform ambiguous intents into precise mathematical constraints, the total effectiveness function J is constructed as a weighted linear combination of S, E, and O:

$$J=\left({\lambda }_s·S+{\lambda }_e·E+{\lambda }_o·O\right)\times 100$$

(8)

where the weight vector $\lambda ={({\lambda }_s,{\lambda }_e,{\lambda }_o)}^T$ is dynamically determined by the parsed preference mode $P_{mode}$, achieving intent alignment by reshaping the Pareto front of multi-objective optimization:

• Balanced Preferences: When $P_{mode}=Balanced$, $\lambda$ follows a uniform distribution, i.e., ${\lambda }_s={\lambda }_e={\lambda }_o$. The model will seek a robust balance among survival, cost, and offense, making it suitable for conventional missions with ambiguous situations.
• Biased Preferences: When $P_{mode}\ne Balanced$, $\lambda$ exhibits a sparse distribution, and the weight of a specific dimension is significantly amplified:

  –

  Survival-oriented ($P_{mode}=Survival$): Extremely sensitive to battle losses, leaning towards generating low-risk or stand-off strike schemes.

  –

  Economic-oriented ($P_{mode}=Economic$): Prioritizes optimizing the cost-effectiveness ratio, leaning towards strike schemes that minimize resource consumption.

  –

  Offensive-oriented ($P_{mode}=Offensive$): Possesses a high tolerance for costs, fully optimizing the offensive metric O, leaning towards adopting rapid saturation attacks.

2.4. Definition of Physical Hallucination

While the aforementioned S-E-O evaluation model establishes the quantitative criteria for assessing the effectiveness of a valid allocation plan, pure semantic LLMs frequently generate schemes that fundamentally violate underlying physical and logical boundaries. To formally contextualize the core challenges our methodology aims to resolve, we introduce the concept of physical hallucination and decompose it into three distinct failure modes:

• Capability Constraint Violation: This category occurs when the assigned tasks exceed the inherent physical capabilities of the platforms or violate global objective constraints. Typical instances include assigning attack payloads to reconnaissance-only UAVs (violating the zero-load rule), mixing incompatible munition types on a single drone, or drafting plans where the aggregate munition consumption exceeds the global inventory limits.
• Range Exceedance Error: This error manifests as flawed spatial reasoning or inaccurate numerical estimations. A primary example is targeting enemy units that lie beyond the UAV’s maximum operational range or the kinematic reach of its deployed munitions.
• State and Sequence Conflict: This represents complex logical inconsistencies within multi-wave sequencing, asset lifecycle management, and tactical coordination. It encompasses state-tracking failures (e.g., “asset resurrection,” where a single-use suicide drone is erroneously deployed across multiple rounds) and tactical coordination violations (e.g., exceeding the strict limit of one electronic warfare unit per wave, or separating an escort from its designated strike aircraft into different rounds). Furthermore, it includes severe tactical causality inversions, such as deploying vulnerable bombers prior to executing the SEAD.

By formally isolating these three structural failure modes, we establish a targeted foundation for the generative paradigm proposed in Section 3, where each type of physical hallucination is explicitly mitigated by a dedicated module within the heterogeneous toolchain.

3. Methodology

3.1. Generative Paradigm Augmented by Heterogeneous Toolchain

To overcome the cognitive overload of monolithic models under high-dimensional spatiotemporal constraints and transition task allocation from numerical fitting to tactical reasoning, this paper proposes a generative task allocation architecture augmented by a heterogeneous toolchain. To explicitly elucidate the dynamic information flow and the closed-loop interactions between the planning and execution spaces, Figure 2 breaks down the execution pipeline into a seven-step numbered sequence. This paradigm orthogonally decomposes the Markov process of task generation into two independently optimized and deeply collaborative modules:

• Tactical Planner (${\pi }_{\varphi }$): Operates in the high-dimensional semantic space. It utilizes the CoT to parse ambiguous intents and conduct tactical deduction, outputting interpretable intermediate semantic instructions rather than direct control signals.
• Tool Executor (${\pi }_{\theta }$): Anchored in the low-dimensional physical manifold. Through constrained decoding, it strictly maps the natural language instructions into compliant tool invocation codes.

  Table 2. Definitions of the five categories of heterogeneous tools and their input–output paradigms.

  Tool Name	Symbol	Definition	Input	Output
  Excellent Case Retrieval	$T_{ret}$	Retrieves successful historical tactical cases based on situational similarity.	scene, preference, currentSituation	One-shot historical tactical case.
  Knowledge Graph Query	$T_{kg}$	Queries static attributes (e.g., range and damage radius) to mitigate model hallucination.	queryEntity	Equipment attributes and static parameters.
  Geospatial Calculator	$T_{calc}$	Calculates Euclidean distances between multiple coordinates for spatial analysis.	listA, listB, currentSituation	Euclidean distance matrix.
  Risk-Cost Calculator	$T_{cost}$	Evaluates operational risks and economic costs to support decision-making.	uavList, targetList, currentSituation	Combat loss costs.
  Simulation Evaluation	$T_{sim}$	Parses plans into instruction sequences, executes simulation, and returns feedback.	assignmentJson, currentSituation	Efficacy score and detailed battle report.

  Note: currentSituation contains dynamic states such as red_aircraft_stock and blue_platforms.

  presents the five categories of heterogeneous tools defined in this study and their input–output paradigms.

Specifically, the dynamic information flow within this architecture is executed through the following seven-step closed-loop sequence:

• Step 1 (Input Processing): The current situation $\mathcal{S}$ and instruction $\mathcal{I}$ are fed into the Tactical Planner, initiating preference and scenario analysis followed by CoT reasoning.
• Step 2 (Intent Decomposition): The Planner generates a natural language (NL) intermediate instruction and transmits it to the Tool Executor.
• Step 3 (Constrained Invocation): The Executor translates the NL instruction into a structured JSON format via constrained decoding, triggering valid tool calls to Group 1 (Auxiliary Tools).
• Step 4 (Observation Feedback): The execution results from Group 1 are returned to the Planner as environmental observations, forming a short-cycle cognitive loop to update the CoT context.
• Step 5 (Simulation Trigger): For critical decision nodes, the Executor invokes Group 2 tools ($T_{sim}$) to simulate the proposed actions.
• Step 6 (Simulation Feedback): The simulation engine evaluates the action sequence and returns the score J as long-cycle feedback to the Planner for tactical refinement.
• Step 7 (Plan Generation): Once the evaluation score meets the performance threshold ($J\ge \delta$), the system halts the loop and outputs the Final Plan.

Beyond defining functional boundaries (Table 2), the invocation of these tools is governed by a prompt-driven workflow with conditional logic. This allows the Tactical Planner to organize the toolchain sequentially across three phases:

• Initialization Phase ($T_{ret}$ and $T_{kg}$): Upon receiving an intent, the system first invokes $T_{ret}$ to retrieve historical cases as a reasoning baseline, followed by $T_{kg}$ to extract static physical constraints (e.g., payload limits) for the entities involved.
• Context-Aware Computation Phase ($T_{calc}$ and $T_{cost}$): Tool selection adapts dynamically to the tactical context. $T_{calc}$ is typically triggered before spatial assignments to provide distance matrices. Meanwhile, $T_{cost}$ is invoked conditionally based on commander preferences; for example, an “economic” intent triggers risk-cost filtering prior to platform selection.
• Feedback-Driven Iteration Phase ($T_{sim}$): To validate the draft plan, the system invokes $T_{sim}$. If the efficacy score J falls below the threshold ($\delta =90$), the model leverages the returned battle report to adjust tactical sequencing or payloads, repeating this closed-loop refinement until the performance criteria are satisfied.

Through this workflow, heuristic semantic reasoning is effectively grounded in quantitative computation. Furthermore, decoupling tactical reasoning from tool execution helps mitigate multi-task gradient interference, providing a structural basis for the subsequent orthogonal evolution training.

3.2. Orthogonal Evolution Training Method

Based on the architecture in Section 3.1, this paper proposes an execution-manifold-anchored orthogonal evolution training method oriented towards heterogeneous dual-models. Addressing the challenges of data scarcity and gradient conflicts typical in end-to-end monolithic training, this strategy utilizes a temporal decoupling mechanism. Instead of optimizing the two models simultaneously, we separate their training phases to reflect their inherent causal dependency. Specifically, the advanced value alignment of the Tactical Planner (via the RCP algorithm) naturally requires high-fidelity counterfactual feedback from the simulation environment. To guarantee the quality of this feedback, we first solidify the “execution manifold” by training and freezing the Tool Executor as a deterministic, rule-abiding translation interface. With this reliable execution anchor established to interact with external tools, the training focus can then orthogonally shift to refining the Tactical Planner. The entire process employs Low-Rank Adaptation (LoRA) [35] for parameter-efficient fine-tuning, efficiently injecting domain tactical knowledge while retaining the general semantic capabilities of the foundational models.

To provide a clear algorithmic overview of this strategy and facilitate reproducibility, Algorithm 1 summarizes the step-by-step workflow. The detailed implementations of the three main phases are sequentially elaborated in the following subsections.

Algorithm 1 Orthogonal evolution of heterogeneous dual-models.

Input: Base Planner ${\pi }_{{\varphi }_0}$ and Executor ${\pi }_{{\theta }_0}$, Seed dataset ${\mathcal{D}}_{seed}$, Env $\mathcal{E}$

Output: Optimized Planner ${\pi }_{{\varphi }^{\mathsf{\ast }}}$ and Grounded Executor ${\pi }_{{\theta }^{\mathsf{\ast }}}$

Phase 1: Trajectory Synthesis and Decoupling

1: ${\mathcal{D}}_{total}\leftarrow$ Synthesize trajectories based on ${\mathcal{D}}_{seed}$ and State Transition Graph

2: ${\mathcal{D}}_{plan}\leftarrow {\mathrm{\Phi }}_{plan}\left({\mathcal{D}}_{total}\right)$                                      ▹ Mask underlying tool execution details

3: ${\mathcal{D}}_{exec}\leftarrow {\mathrm{\Phi }}_{exec}\left({\mathcal{D}}_{total}\right)$                                            ▹ Extract instruction-to-action pairs

Phase 2: Execution Manifold Anchoring (via LoRA)

4: ${\pi }_{{\theta }_{sft}}\leftarrow {\arg \min }_{\mathrm{\Delta }\theta }{\mathcal{L}}_{SFT}\left({\mathcal{D}}_{exec}\right)$                                            ▹ Initialize base mapping

5: for each instruction $i_t\in {\mathcal{D}}_{exec}$ do

6:     Sample candidate actions ${\left\{a_t^k\right\}}_{k=1}^K\sim {\pi }_{{\theta }_{sft}}(·\mid i_t)$

7:     Compute rule-based binary rewards $r_{rule}\left(a_t^k\right)\in \{0,1\}$

8:     ${\pi }_{{\theta }^{\mathsf{\ast }}}\leftarrow {\arg \min }_{\mathrm{\Delta }\theta }{\mathcal{L}}_{GSPO}$                                            ▹ Reward-driven policy optimization

9: end for

10: Freeze Executor parameters ${\pi }_{{\theta }^{\mathsf{\ast }}}$

Phase 3: Planning Value Alignment (via LoRA)

11: ${\pi }_{{\varphi }_{sft}}\leftarrow {\arg \min }_{\mathrm{\Delta }\varphi }{\mathcal{L}}_{SFT}\left({\mathcal{D}}_{plan}\right)$                                            ▹ Align semantic reasoning

12: ${\mathcal{T}}_{fail}\leftarrow$ Collect failed rollouts via self-play between ${\pi }_{{\varphi }_{sft}}$ and frozen ${\pi }_{{\theta }^{\mathsf{\ast }}}$ in $\mathcal{E}$

13: ${\mathcal{D}}_{dpo}\leftarrow \mathrm{RCP}({\mathcal{T}}_{fail},{\pi }_{{\varphi }_{sft}},{\pi }_{{\theta }^{\mathsf{\ast }}})$                                            ▹ Extract causal preference slices via Algorithm 2

14: ${\pi }_{{\varphi }^{\mathsf{\ast }}}\leftarrow {\arg \min }_{\mathrm{\Delta }\varphi }{\mathcal{L}}_{DPO}\left({\mathcal{D}}_{dpo}\right)$                                            ▹ DPO preference alignment

15: return  ${\pi }_{{\varphi }^{\mathsf{\ast }}},{\pi }_{{\theta }^{\mathsf{\ast }}}$

3.2.1. Heterogeneous Data Construction

To address the scarcity of domain expert data, we propose a few-shot data augmentation approach. By leveraging a small set of expert demonstrations and structured generation constraints, we expand sparse initial samples into a comprehensive training set. Figure 3 illustrates this process.

(1) Expert Seed Construction

To establish a reliable baseline, domain experts constructed a seed set ${\mathcal{D}}_{seed}$ of 50 high-quality samples. Formatted in structured JSON, these seeds contain the initial situation, commander instructions, and standardized multi-round Tool-CoT trajectories. The seed selection aims for broad coverage, ensuring a balanced distribution across preference-scenario tuples $(P_{mode},T_{scenario})$ and diverse trigger conditions for all available tools.

(2) Exemplar-Guided Topology-Constrained Synthesis

We utilize in-context learning (ICL) with a general LLM (Gemini-3.0-Pro via API, with Temperature=0.7 and Top-P=0.9 to balance generation diversity and tactical coherence) for large-scale data expansion. The prompt strategy incorporates a system persona, structured state observations, and a retrieved few-shot exemplar from ${\mathcal{D}}_{seed}$ to provide tactical context.

• Tactical Prior Injection: Samples one highly similar expert seed from ${\mathcal{D}}_{seed}$ as the In-Context Exemplar, implicitly transferring tactical logic through in-context learning.
• Dynamic Topological Constraint: Explicitly defines the State Transition Graph $G_{STG}$ within the prompt, forcing the model to execute a recursive loop of $\mathrm{Instruction}\to {(\mathrm{Thought}\to \mathrm{Tool\_Call}\to \mathrm{Observation})}^k\to \mathrm{Finish}$. During generation, we integrated the LangGraph framework as the orchestration middleware. LangGraph programmatically instantiates the $G_{STG}$ as a cyclic graph, reliably routing the model’s Tool_Call to local Python tool nodes and sequentially injecting the real-time execution feedback back as the Observation. This mechanism drives the model to conduct multi-round closed-loop corrections, effectively circumventing the open-loop hallucinations of general models, thereby generating a complete trajectory set ${\mathcal{D}}_{total}$.

(3) Heterogeneous Data Decoupling

To support the dual-model architecture, the generated dataset ${\mathcal{D}}_{total}$ is split into two specialized subsets:

• Planning Data (${\mathcal{D}}_{plan}$): Created via a masking mapping ${\mathrm{\Phi }}_{plan}:\tau \to (\mathcal{S},\mathcal{I},H_{<t},c_t,i_t)$, which hides the low-level tool execution details, allowing the planner ${\pi }_{\varphi }$ to focus on tactical reasoning and intent decomposition.
• Execution Data (${\mathcal{D}}_{exec}$): Created via an extraction mapping ${\mathrm{\Phi }}_{exec}:\tau \to \left(i_t,a_t\right)$, which isolates instruction-to-action pairs, enabling the executor ${\pi }_{\theta }$ to focus strictly on precise tool invocation.

3.2.2. Execution Manifold Anchoring

This stage adopts a time-series decoupling strategy, temporarily freezing the planning model ${\pi }_{\varphi }$ to focus on anchoring the execution model ${\pi }_{\theta }$ as a highly reliable universal tool foundation. Using the LoRA strategy, the backbone parameters ${\theta }_0$ are frozen, and only the low-rank matrices $\mathrm{\Delta }\theta$ injected into the attention layers are optimized.

Based on this architecture, we train the model using the execution dataset ${\mathcal{D}}_{exec}$. To compel the model to rapidly acquire the tool format norms $K_{schema}$, we employ Supervised Fine-Tuning (SFT) [36] to minimize the negative log-likelihood loss from instruction $i_t$ to action $a_t$:

$${\mathcal{L}}_{SFT}\left(\mathrm{\Delta }\theta \right)=-{\mathbb{E}}_{(i_t,K_{schema},a_t)\sim {\mathcal{D}}_{exec}}\left[log{\pi }_{{\theta }_0+\mathrm{\Delta }\theta }\left(a_t\right|i_t,K_{schema})\right]$$

(9)

However, models subjected only to SFT still exhibit output hallucinations caused by long-tail distribution shifts when handling multi-parameter dependencies or numerical boundaries.

To suppress these hallucinations, we introduce the Grouped Stochastic Policy Optimization (GSPO) algorithm [37]. This method discards the high-variance value networks and utilizes formalized rules as parameter-free hard constraints. Specifically, for a given instruction $i_t$, K groups of candidate actions $\{a_t^1,\dots ,a_t^K\}$ are sampled in parallel to construct a binarized reward function $r_{rule}\left(a_t^k\right)\in \{0,1\}$. The policy is updated by maximizing the relative generation probability of compliant actions within the group:

$${\mathcal{L}}_{GSPO}\left(\mathrm{\Delta }\theta \right)=-{\mathbb{E}}_{i_t\sim {\mathcal{D}}_{exec}}\left[log{\displaystyle \frac{{\displaystyle \sum _{k=1}^K{\pi }_{{\theta }_0+\mathrm{\Delta }\theta }\left(a_t^k\right|i_t)·r_{rule}\left(a_t^k\right)}}{{\displaystyle \sum _{k=1}^K{\pi }_{{\theta }_0+\mathrm{\Delta }\theta }\left(a_t^k\right|i_t)}}}\right]$$

(10)

This process effectively concentrates the probability mass of the policy network from the illegal space toward the manifold region satisfying $r_{rule}=1$, solidifying the model into a highly reliable execution foundation ${\pi }_{{\theta }^{\mathsf{\ast }}}$, which provides a physical consistency guarantee for subsequent tactical planning training.

3.2.3. Planning Model Value Alignment

After anchoring the highly reliable execution foundation ${\pi }_{{\theta }^{\mathsf{\ast }}}$, this stage focuses on enhancing the tactical decision-making capabilities of the planning model ${\pi }_{\varphi }$. The entire process also employs the LoRA strategy, freezing the backbone parameters ${\varphi }_0$ and optimizing only the incremental parameters $\mathrm{\Delta }\varphi$.

First, SFT is implemented on ${\pi }_{\varphi }$ using the planning model dataset ${\mathcal{D}}_{plan}$. An action masking mechanism is employed to filter out the underlying tool invocation details, forcing the model to concentrate on long-horizon intent decomposition and tactical logical deduction. The optimization objective is to minimize the negative log-likelihood loss of tactical thoughts and intermediate instructions:

$${\mathcal{L}}_{SFT}\left(\mathrm{\Delta }{\varphi }_{sft}\right)=-{\mathbb{E}}_{(\mathcal{S},\mathcal{I},H_{<t},c_t,i_t)\sim {\mathcal{D}}_{plan}}\left[log{\pi }_{{\varphi }_0+\mathrm{\Delta }{\varphi }_{sft}}(c_t,i_t|\mathcal{S},\mathcal{I},H_{<t})\right]$$

(11)

Although this stage endows the model with basic tactical common sense, it is still unable to handle the dynamic feedback and complex causal chains in long-horizon games.

To this end, we connect the trained planning model ${\pi }_{{\varphi }_0+\mathrm{\Delta }{\varphi }_{sft}}$ and the frozen execution model ${\pi }_{{\theta }^{\mathsf{\ast }}}$ from the previous section into the simulation environment to conduct alternating self-play. As shown in Figure 4, this process constructs a low-noise tactical data generation engine, ensuring that all effectiveness discrepancies can be attributed to the quality of tactical logic.

Addressing the credit assignment bias of the traditional Direct Preference Optimization (DPO) algorithm [38] in long-horizon tasks, we introduce the RCP algorithm detailed in Section 3.3. Through counterfactual deduction, this algorithm bypasses the coarse-grained global return J, precisely extracts key tactical slices with causal significance, and constructs a high-confidence preference set ${\mathcal{D}}_{dpo}=\left\{(H,y_w,y_l)\right\}$. Subsequently, the DPO algorithm is utilized to optimize the policy network:

$${\mathcal{L}}_{DPO}\left(\mathrm{\Delta }\varphi \right)=-{\mathbb{E}}_{(H,y_w,y_l)\sim {\mathcal{D}}_{dpo}}log\sigma \left(\beta log{\displaystyle \frac{{\pi }_{{\varphi }_0+\mathrm{\Delta }\varphi }\left(y_w\right|H)}{{\pi }_{ref}\left(y_w\right|H)}}-\beta log{\displaystyle \frac{{\pi }_{{\varphi }_0+\mathrm{\Delta }\varphi }\left(y_l\right|H)}{{\pi }_{ref}\left(y_l\right|H)}}\right)$$

(12)

where ${\pi }_{ref}={\pi }_{{\varphi }_0+\mathrm{\Delta }{\varphi }_{sft}}$ is the planning model from the SFT stage. This objective function ensures that the gradient update ${\nabla }_{\mathrm{\Delta }\varphi }$ strictly points towards the solution space that conforms to physical constraints and maximizes tactical causality.

3.3. Recursive Causal Probe Algorithm

Addressing the challenge of ambiguous credit assignment in long-horizon games, this section proposes a dynamic decision attribution algorithm based on the RCP. Existing attribution paradigms generally face notable limitations in this context: traditional methods [39,40] (such as reinforcement learning utilizing Generalized Advantage Estimation) can be susceptible to signal dilution over extended sequences [41], while LLM-based counterfactual reasoning (e.g., Reflexion [42]) relies primarily on semantic self-reflection, which may lack strict physical grounding. To bridge this gap, RCP adopts a dynamic backward-tracing paradigm with physical counterfactual intervention. By evaluating alternative decisions directly within the simulation, it seeks to isolate the minimal causal unit responsible for task failure, thereby reducing reliance on sparse rewards or purely semantic inferences.

The overall workflow is illustrated in Figure 5 and formally detailed in Algorithm 2. Specifically, given a failed trajectory ${\tau }_{fail}=\{(c_1,i_1),\dots ,(c_T,i_T)\}$ where the terminal effectiveness falls below the success threshold ($J<\delta$), the algorithm proceeds through the following structured phases:

• Step 1 (Backward Tracing): The algorithm traces back frame-by-frame starting from the terminal step T. At any given time t, the historical context $H_{<t}$ is frozen.
• Step 2 (Counterfactual Generation): A counterfactual intervention is applied to the planning policy ${\pi }_{\varphi }$. Using Monte Carlo sampling, the model generates M alternative candidate branches $\mathcal{B}=\{y_1^{\prime },\dots ,y_M^{\prime }\}$ that deviate from the original failure-inducing decision $y_l=(c_t,i_t)$.
• Step 3 (Multi-Turn Rollout): Utilizing the frozen execution model ${\pi }_{{\theta }^{\mathsf{\ast }}}$, each of the M candidate branches ($y^{\prime }\in \mathcal{B}$) undergoes a closed-loop forward rollout. Starting by executing the alternative decision $y^{\prime }$, the planner iteratively reasons and invokes necessary tools up to a predefined maximum number of simulation turns $N_{max}$:

  $${\tau }_{branch}^{\prime }=\mathrm{Rollout}\left({\pi }_{\varphi },{\pi }_{{\theta }^{\mathsf{\ast }}},H_{<t},y^{\prime },N_{max}\right)$$

  (13)
• Step 4 (Causal Extraction and Early Stopping): If a forward rollout successfully achieves the mission objective ($J\left({\tau }_{branch}^{\prime }\right)\ge \delta$) within the maximum allowed turns, time t is identified as the Tactical Turning Point. The corrective decision is extracted as the positive sample $y_w$ to form the preference pair ${\mathcal{D}}_{dpo}=\left\{(H_{<t},y_w,y_l)\right\}$. To isolate the minimal causal unit and reduce computational overhead, the backward search terminates immediately once the first valid turning point is found.

Algorithm 2 Recursive Causal Probe (RCP).

Input: Failure set ${\mathcal{T}}_{fail}$, Planner ${\pi }_{\varphi }$, Executor ${\pi }_{{\theta }^{\mathsf{\ast }}}$, Score function J, Threshold $\delta$, Sample size M, Max simulation iteration turns $N_{max}$

Output: Causal Preference Dataset ${\mathcal{D}}_{dpo}$

1: ${\mathcal{D}}_{dpo}\leftarrow \varnothing$

2: for each trajectory $\tau =\{(c_1,i_1),\dots ,(c_T,i_T)\}\in {\mathcal{T}}_{fail}$ do

3:     for $t\leftarrow T$ down to 1 do

4:         $H_{<t}\leftarrow$ Historical context up to step t

5:         $y_l\leftarrow (c_t,i_t)$

6:         Generate candidate branches via Monte Carlo sampling: $\mathcal{B}\leftarrow {\mathrm{Sample}}_{MC}({\pi }_{\varphi }(·\mid H_{<t}),M)$

7:         Evaluate multi-turn rollout up to $N_{max}$:

8:         $\mathcal{V}\leftarrow \left\{y^{\prime }\in \mathcal{B}\setminus \left\{y_l\right\}\mid J\left(\mathrm{Rollout}({\pi }_{\varphi },{\pi }_{{\theta }^{\mathsf{\ast }}},H_{<t},y^{\prime },N_{max})\right)\ge \delta \right\}$

9:         if $\mathcal{V}\ne \varnothing$ then

10:            Select a successful corrective decision $y_w\in \mathcal{V}$

11:            ${\mathcal{D}}_{dpo}\leftarrow {\mathcal{D}}_{dpo}\cup \left\{(H_{<t},y_w,y_l)\right\}$

12:            break

13:         end if

14:     end for

15: end for

16: return  ${\mathcal{D}}_{dpo}$

Theoretically, exhaustive backward tracing scales as $\mathcal{O}(M·T^2)$ for a trajectory of length T. However, the early stopping mechanism (Algorithm 2, Line 12) effectively mitigates this worst-case quadratic bound. By terminating the search upon discovering the first valid turning point, the practical search depth is substantially reduced. Consequently, the actual wall-clock efficiency depends on the sampling size M, which influences the probability of early termination. A detailed empirical analysis of this computational overhead and the ablation of M under hardware constraints is presented in Section 4.4.2.

4. Experiments

To verify the effectiveness of the proposed generative allocation paradigm in complex battlefield environments, this paper conducts extensive comparative and ablation experiments.

4.1. Dataset Construction

To assess tactical planning, tool execution, and RCP performance, we established training and evaluation datasets across diverse scenarios (detailed in

Table 3. Datasets used for training and testing. The training datasets were automatically synthesized via Gemini-3.0-Pro based on expert seeds, while the test sets were manually curated by domain experts to ensure rigorous evaluation.

Dataset	Total Samples	Avg. Length	Category
${\mathcal{D}}_{plan}$	5000	16,583.10	TrainingSet
${\mathcal{D}}_{exec}$	31,338	1656.63	TrainingSet
${\mathcal{D}}_{dpo}$	3000	31,743.59	TrainingSet
${\mathcal{D}}_{rcp}$	100	32,007.11	TestSet
${\mathcal{D}}_{test}$	300	1265.12	TestSet
${\mathcal{D}}_{test-tool}$	1000	1581.56	TestSet

Note: The average length refers to the average number of tokens in each dataset under the corresponding tokenizer; the DPO dataset is calculated using the maximum length of the positive and negative sample pairs.

).

(1) Training Dataset Construction:

Based on the data synthesis method in Section 3.2.1, we generated 5000 high-quality Tool-CoT trajectories and accordingly constructed three training sets:

• Planning Model Dataset (${\mathcal{D}}_{plan}$): Directly adopts the 5000 complete trajectory samples mentioned above to fine-tune the long-horizon reasoning capability of the planning model.
• Execution Model Dataset (${\mathcal{D}}_{exec}$): Comprises a total of 31,338 instruction–action pairs extracted from the 5000 complete trajectories. As detailed in Section 3.2.1, this large volume (averaging ∼6.3 pairs per trajectory) intrinsically reflects the dense multi-tool invocation nature of complex tactical reasoning. However, to prevent overfitting to frequently invoked but structurally simple tools during actual training, this total dataset undergoes a difficulty-aware downsampling. Specifically, we strictly retain all complex samples ($T_{sim}$ and $T_{cost}$) while proportionally downsampling the remaining simpler tool types, thereby ensuring a balanced representation prior to execution model training.
• Preference Alignment Dataset (${\mathcal{D}}_{dpo}$): Utilizing the self-play engine and the RCP algorithm, 3000 pairs of preference samples were automatically filtered for alignment training during the DPO stage.

(2) Test Dataset Construction:

To evaluate tactical planning, tool execution, and RCP sampling performance, three evaluation sets were constructed:

• Tactical Reasoning Test Set (${\mathcal{D}}_{test}$): Contains 300 complex tactical base situations. To ensure statistical confidence and mitigate the impact of environmental stochasticity, each base situation is evaluated across three independent randomized runs. These samples evenly cross-cover five typical tactical scenarios and four command preferences to provide a robust assessment of overall planning effectiveness.
• Atomic Tool Test Set (${\mathcal{D}}_{test-tool}$): Contains 1000 independent invocation instructions, symmetrically covering all five categories of heterogeneous tools to individually verify the robustness of the execution foundation.
• Causal Probe Dataset (${\mathcal{D}}_{rcp}$): Comprises 100 failed trajectories extracted to analyze the computational overhead and sampling efficiency of the RCP algorithm. This dataset serves as the basis for the ablation study of the sampling parameter M in Section 4.4.2.

4.2. Experimental Setups

4.2.1. Experimental Platform Configuration

The experimental evaluations are conducted within the Advanced Framework for Simulation, Integration, and Modeling (AFSIM, version 2.9.0), a high-fidelity simulation engine. The underlying computational framework operates on an Ubuntu 22.04 LTS system powered by an Intel Xeon Gold 5418Y CPU, 256 GB of memory, and NVIDIA H100 (80 GB) GPU. This hardware is paired with a deep learning software stack comprising Python 3.10.18, PyTorch 2.10.0, and CUDA 12.8. Deployed upon this infrastructure, the proposed heterogeneous dual-model architecture employs GPT-OSS-20B as the planning model to facilitate long-horizon tactical reasoning, paired with Qwen3-4B-Instruct as the execution model.

4.2.2. Evaluation Metrics

To ensure the objectivity and discriminability of the scoring, the parameters of the S-E-O evaluation framework are instantiated as follows:

(1) Offensive Score (O): Sets the base effectiveness weight at ${\gamma }_{base}=0.9$ to ensure task completion rate dominance, while time efficiency provides at most 10% marginal gain:

$$O={\eta }_{task}·\left[0.9+0.1·max\left(0,1-\tau /{\tau }_{max}\right)\right]$$

(14)

(2) Survival Score (S): This calculation utilizes the set difference $|{\mathcal{U}}_{total}\setminus {\mathcal{U}}_{suicide}|$ to explicitly exclude the predefined suicide UAV set, calculating only the survival rate of reconnaissance and strike UAVs.

(3) Economic Score (E): Sets the cost-effectiveness ratio saturation threshold at ${\rho }_{sat}=150.0$, guiding the model to prioritize asymmetric, high-efficiency strikes under resource-constrained conditions.

For the linear total effectiveness function J, the preference weight vector $\lambda$ is configured as follows:

(1) Balanced Preference ($P_{mode}=Balanced$): Uniform weight distribution (${\lambda }_s={\lambda }_e={\lambda }_o=1/3$), aiming to eliminate the short-board effect and guide the model to generate robust, multi-dimensional balanced schemes.

(2) Biased Preference ($P_{mode}\ne Balanced$): Weights exhibit a low-entropy sparse distribution. Let the primary dimension weight be ${\lambda }_{pri}=0.7$ and the secondary dimension weight be ${\lambda }_{sec}=0.15$. Taking the economic-oriented preference as an example, the weight vector is ${[0.15,0.7,0.15]}^T$, forcing the model to prioritize searching the solution space for high cost-effectiveness.

4.2.3. Baseline Algorithms and Models

To evaluate the proposed paradigm, we selected foundational algorithms from distinct methodological categories as baselines. This approach helps explore the characteristics of different problem-solving pathways (e.g., numerical optimization vs. semantic generation) without relying on highly domain-specific variants:

• Ant Colony Optimization (ACO) [43]: A representative heuristic algorithm, serving as a basic reference for discrete combinatorial search.
• Deep Q-Network (DQN) [44] and Proximal Policy Optimization (PPO) [41]: Selected as foundational value-based and policy-gradient DRL methods. Given our centralized task formulation, they help observe common challenges—such as dimensionality scaling and sparse-reward degradation—often encountered by conventional end-to-end numerical paradigms lacking semantic priors.
• Gemini-3.0-Flash and GLM-5 [45]: Selected as representative monolithic large language models. To ensure a fair structural comparison, these models are equipped with the same heterogeneous toolchain via Few-shot Prompting. This configuration serves as a direct control group to help illustrate the performance differences between conventional single-model tool invocation and our proposed decoupled dual-model paradigm.

4.2.4. Training Hyperparameters

To facilitate reproducibility and ensure a fair comparison, we carefully tuned the hyperparameters across all evaluated methods. The primary tuning criterion was to maximize the overall average evaluation score within acceptable training or inference timeframes, thereby balancing algorithmic performance with computational efficiency. For methodological transparency, all specific configurations—including the parameters for the heuristic and RL baselines, the inference settings for the general LLMs, and both the fine-tuning (LoRA, GSPO) and inference setups for our proposed dual-model architecture—are detailed in Appendix A.

4.3. Comparative Experiments

To evaluate the proposed heterogeneous dual-model paradigm on the test set ${\mathcal{D}}_{test}$, we compared it against traditional heuristic/reinforcement learning algorithms (ACO, DQN; PPO) and general large language models (GLM-5, Gemini-3.0-Flash). Since traditional baselines cannot directly process natural language, their inputs were manually translated into numerical constraint matrices; additionally, rule-based action masking was applied during their sampling phases to help minimize basic rule violations. The evaluation comprehensively covers macro-level task effectiveness—including mission success rate (MSR), Average Task Score (Avg. Score), and average interactive turns (Avg. Turns)—as well as micro-level logical robustness. This robustness is measured by three dedicated metric rates corresponding to the physical hallucinations formulated in Section 2.4: Capability Constraint Violation Rate (CCVR), Range Exceedance Rate (RER), and State and Sequence Conflict Rate (SSCR). The overall quantitative results are summarized in

Table 4. Overall performance and physical hallucination comparison of different algorithms on the test set. Performance metrics are reported as Mean ± Standard Deviation across three independent runs. To control time consumption, the maximum iterations for ACO are set to ten turns, and for LLMs to five turns. The shaded row highlights the performance of our proposed model.

Model	Performance Metrics			Hallucination Rates (%)
	MSR (%)	Avg. Score	Avg. Turns	CCVR	RER	SSCR
ACO	62.34 ± 2.45	82.16 ± 1.92	5.42 ± 0.38	0.00 ± 0.00 †	0.00 ± 0.00 †	0.00 ± 0.00 †
DQN	43.00 ± 4.18	72.38 ± 3.75	1.00 ± 0.00	0.00 ± 0.00 †	0.00 ± 0.00 †	0.00 ± 0.00 †
PPO	27.00 ± 5.62	61.19 ± 4.21	1.00 ± 0.00	0.00 ± 0.00 †	0.00 ± 0.00 †	0.00 ± 0.00 †
GLM-5 1	55.67 ± 2.76	85.51 ± 1.84	3.52 ± 0.22	12.50 ± 1.15	10.40 ± 1.82	53.12 ± 3.44
Gemini-3.0-Flash 1	55.00 ± 3.14	84.12 ± 2.05	3.64 ± 0.18	11.00 ± 1.68	12.30 ± 0.95	40.00 ± 2.87
Ours	82.34 ± 1.42	93.17 ± 0.94	2.69 ± 0.12	6.10 ± 0.73	7.87 ± 0.58	15.10 ± 1.05

¹ The GLM-5 and Gemini models utilized the five tools designed in this paper for closed-loop reasoning. ^† Traditional algorithms (ACO, DQN; PPO) achieve strictly 0.00 ± 0.00% in Hallucination Rates due to hard-coded action masking and rule pruning, not generalized semantic understanding.

.

Experimental results indicate that traditional baselines and general models both possess significant limitations when handling complex tactical planning:

• Traditional Baselines (ACO/DQN/PPO): Although the heuristic ACO maintained a reasonable average score of 82.16, its MSR was 62.34% with an average of 5.42 interactive turns, indicating that heuristic search often struggles to converge efficiently within limited steps. Conversely, the DRL methods (DQN and PPO) experienced notable policy degradation due to sparse rewards and vast action spaces; despite rapid single-turn decision-making, their MSRs dropped to 43.00% and 27.00%, respectively, limiting their consistent mission completion.
• General LLMs (GLM-5/Gemini-3.0-Flash): Benefiting from inherent semantic reasoning capabilities, both models achieved competitive average scores (85.51 and 84.12). However, as monolithic architectures, they appear to face challenges in internalizing strict physical boundaries. This is reflected in their relatively high State and Sequence Conflict Rates (SSCRs of 53.12% and 40.00%), leading to sub-optimal MSRs (∼55%) despite multiple trial-and-error corrections via tool feedback.
• Proposed Method (Ours): By decoupling tactical reasoning from tool execution, our architecture achieved an MSR of 82.34% and the highest average score (93.17). Importantly, this advantage appears to extend beyond a simple distillation effect from the stronger Gemini-3.0-Pro model used for data synthesis. If the performance gains were predominantly driven by inherited semantic priors, the model would likely still exhibit the high physical conflict rates common among monolithic architectures. Instead, our method substantially mitigated physical hallucinations (e.g., SSCR reduced to 15.10%, CCVR to 6.10%). This suggests that the structural decoupling, combined with targeted physical alignment (GSPO and RCP), plays a primary role in anchoring semantic logic to physical constraints.

To further evaluate the tactical logic, we selected three typical heterogeneous situations from the test set. Figure 6 displays the 3D simulation deployment snapshots, and Figure 7 projects them into 2D task allocation topologies, clearly revealing the logical discrepancies among the methods regarding wave planning and target allocation (allocation statistics are in

Table 5. Comparison of task assignment metrics across different algorithms and scenarios.

ID	Mission Intent	Pref.	Score (Iterations/UAVs)
			ACO	PPO	DQN	GLM	Gemini	Ours
1	SEAD	Survival	93.66 (8/16)	91.36 (1/40)	97.47 (1/51)	97.76 (2/23)	92.28 (4/21)	93.07 (2/11)
2	Decapitation Strike	Offensive	95.50 (5/17)	96.00 (1/36)	96.26 (1/47)	98.91 (2/24)	96.79 (1/47)	98.11 (1/19)
3	Strategic Paralysis	Balanced	98.95 (7/13)	99.07 (1/47)	99.61 (1/46)	99.60 (4/9)	99.52 (2/11)	99.53 (1/8)

Note: The metrics are formatted as “Score (Convergence Iterations/Active UAVs)”.

).

Experimental results in Table 5 and Figure 7 indicate that existing baselines struggle to optimally balance mission efficacy with resource constraints. Although ACO achieves high scores (e.g., 98.95 in Scenario 3), it incurs notable delays, requiring five–eight iterations to converge. Conversely, DRL methods (PPO and DQN) enable rapid inference but often execute resource-intensive saturation strikes; despite the “Balanced” preference in Scenario 3, they dispatched 47 and 46 UAVs respectively, showing a limited capacity to internalize resource-saving intents. Furthermore, general LLMs (GLM-5 and Gemini) struggle with tactical resource optimization, often relying on repetitive trial-and-error (e.g., four turns in Scenario 1) or overly conservative force allocation (e.g., 47 UAVs in Scenario 2) to ensure success. In contrast, the proposed architecture successfully navigates these trade-offs. While maintaining highly competitive scores (e.g., 98.11 in Scenario 2), it compresses the decision cycle to one–two turns and allocates forces significantly more precisely—utilizing only 19 UAVs under identical conditions. This demonstrates notable improvements in balancing execution speed, cost-effectiveness, and tactical rationality.

4.4. Ablation Studies

To comprehensively deconstruct the sources of effectiveness in the proposed heterogeneous toolchain-augmented paradigm and verify the necessity of the execution manifold anchoring and orthogonal evolution strategies, we designed multi-dimensional ablation experiments.

4.4.1. Empirical Analysis of Multi-Task Gradient Conflicts

Before systematically evaluating the architectural variants, we first empirically investigate a primary optimization challenge in monolithic training—multi-task gradient conflicts—which motivated our decoupled design. To observe these internal dynamics, Figure 8 traces the joint training process of the monolithic end-to-end mode (M2) over 600 steps.

As illustrated in the bottom subplot, after an initial rapid descent, the gradient cosine similarity between the CoT and tool execution (Tool) tasks frequently fluctuates around and occasionally plunges below zero (the pink conflict region). This recurrent negative cosine similarity ($\cos <0$) serves as a strong indicator of destructive interference, suggesting that the optimization directions of the two tasks frequently diverge. Furthermore, an analysis of the gradient norms reveals a pronounced task imbalance in the later stages (steps 200–600): the gradient norm of CoT (red line) largely dominates that of the Tool task (blue line). Since the model tends to fit the low-level tool syntax more readily than the high-dimensional tactical reasoning, the larger CoT updates can negatively interfere with the learned execution representations. Consequently, as shown in the top subplot, this internal gradient competition corresponds to noticeable training instability—the overall training loss plateaus with high-frequency oscillations around 0.2 after step 200, hindering further smooth convergence. These microscopic optimization dynamics provide strong empirical support for the idea that physically decoupling cognition from execution can effectively alleviate the multi-task capacity bottleneck.

4.4.2. RCP Computational Overhead

To evaluate the practical feasibility of the RCP algorithm, we examined the trade-off between exploration breadth and computational overhead. Using the dataset ${\mathcal{D}}_{rcp}$ containing 100 failed trajectories, we conducted three independent trials for each configuration to ensure statistical reliability. The mean total wall-clock time required for data generation across varying M configurations (with $N_{max}=5$) was recorded, as illustrated in Figure 9. Detailed hardware specifications and model inference settings are provided in Section 4.2.1 and Appendix A, respectively.

The total runtime exhibits a U-shaped curve relative to M. As M increases from 1 to 8, the mean elapsed time decreases from 42.0 min to 25.8 min. This indicates that a larger M improves the probability of identifying a valid corrective branch early in the backward traversal, thereby reducing the overall search depth via the early-stopping mechanism. However, as M scales further to 16 or 32, the parallel rollout overhead begins to exceed the concurrency limits of the simulation environment and GPU inference capabilities. This results in significant queuing delays, increasing the mean total time to 37.5 min. Consequently, $M=8$ is selected as the default configuration to optimally balance causal probing efficiency with available system resources.

4.4.3. Training Framework and Architecture Evolution

To fully deconstruct the effectiveness gains of the heterogeneous dual-model architecture and the orthogonal evolution strategy, we constructed eight model variants (M1–M8) from baseline to the complete method on the test set. Evaluation metrics cover task success rate, average score, and average interactive turns; detailed results are shown in

Table 6. Comparison of task allocation results under different ablation configurations. Maximum iterations for all models are set to five turns. Performance metrics are reported as Mean ± Standard Deviation across three independent runs. The shaded row highlights the performance of our proposed model.

ID	Architecture	Configuration		Performance Metrics
		Planner (${\mathit{\pi }}_{\mathit{\varphi }}$)	Executor (${\mathit{\pi }}_{\mathit{\theta }}$)	MSR (%)	Avg. Score	Avg. Turns
M1	Single (Base)	Few-shot	N/A	0.00 ± 0.00	4.09 ± 1.28	5.00 ± 0.00
M2	Single	SFT (${\mathcal{D}}_{total}$)	N/A	24.00 ± 3.82	44.26 ± 5.14	3.91 ± 0.42
M3	Single	SFT (${\mathcal{D}}_{plan}\cup {\mathcal{D}}_{exec}$)	N/A	15.34 ± 4.75	24.07 ± 6.33	4.58 ± 0.21
M4	Dual (Base)	Few-shot	Few-shot	3.00 ± 1.24	55.18 ± 4.88	4.87 ± 0.11
M5	Dual	SFT	SFT	53.67 ± 2.91	83.67 ± 1.76	3.53 ± 0.28
M6	Dual	SFT	GSPO	63.00 ± 2.05	86.27 ± 2.31	3.33 ± 0.15
M7	Dual	DPO (Standard)	GSPO	71.67 ± 1.88	89.91 ± 1.05	3.05 ± 0.09
M8	Dual	DPO (RCP)	GSPO	82.34 ± 1.42	93.17 ± 0.94	2.69 ± 0.12

.

• Architectural Decoupling (M1–M5): The comparison between monolithic (M1–M3) and dual-model (M4–M5) configurations illustrates the potential challenges of multi-objective optimization within a single parameter space. Interestingly, M3 yielded an MSR of only 15.34%, performing even lower than M2 (24.00%). This degradation suggests that forcing a single network to simultaneously handle flexible tactical reasoning and rigid structural syntax likely exacerbates task-specific interference. Conversely, utilizing the identical decoupled data, M5 restored the MSR to 53.67%. This indicates that a key bottleneck in monolithic paradigms may lie in their architectural limitations to isolate interference between heterogeneous decision processes.
• Execution Manifold Anchoring (M5–M6): The introduction of GSPO in M6 contributed to a more stable deterministic execution. While M5 remains susceptible to execution drift during complex reasoning chains, M6 helps mitigate the upward propagation of underlying uncertainties by anchoring a low-noise execution manifold. This mechanism elevated the MSR from 53.67% to 63.00% and reduced the variance in average scores, highlighting the value of establishing a consistent interactive foundation between the planner and the environment.
• Causal Preference Alignment (M7–M8): The transition from M7 to M8 underscores the role of credit assignment in long-horizon tasks. While M7 (standard DPO) improved the MSR to 71.67%, the enhancement in interactive efficiency was relatively modest (3.05 turns). By introducing the RCP algorithm to extract counterfactual causal slices, M8 achieved an MSR of 82.34% and further compressed the interactive cycle to 2.69 turns. This suggests that the RCP algorithm aids in mitigating sparse-reward bias, thereby supporting more robust tactical reasoning through targeted causal attribution.

4.4.4. Execution Manifold Stability

To quantify the effectiveness of the LoRA-GSPO strategy in constructing a deterministic execution manifold, we compared the zero-shot baseline and our fine-tuned variants on the tool benchmark set ${\mathcal{D}}_{test-tool}$. To account for inference randomness and ensure statistical robustness, all evaluations were conducted across three independent trials. The evaluation focuses on the mean Execution Accuracy (EA) and Schema Error Rate (SER) as core metrics; the results are presented in

Table 7. Comparison of invocation capabilities on the heterogeneous toolchain among different models. Bold numbers indicate the best performance.

Model	EA (%)						SER (%)
	${\mathit{T}}_{\mathit{ret}}$	${\mathit{T}}_{\mathit{kg}}$	${\mathit{T}}_{\mathit{calc}}$	${\mathit{T}}_{\mathit{cost}}$	${\mathit{T}}_{\mathit{sim}}$	Avg.
Base	$96.58\pm 0.85$	$99.15\pm 0.43$	$66.67\pm 1.07$	$73.02\pm 3.17$	$48.01\pm 1.08$	$77.30\pm 0.40$	$2.30\pm 0.20$
Gemini-3.0-Flash	$\mathbf{100.0}\pm 0.00$	$\mathbf{100.0}\pm 0.00$	$95.60\pm 0.49$	$93.65\pm 1.59$	$\mathbf{94.02}\pm 0.43$	$97.17\pm 0.25$	$\mathbf{0.00}\pm 0.00$
GLM-5	$99.72\pm 0.25$	$\mathbf{100.0}\pm 0.00$	$98.01\pm 0.65$	$84.66\pm 2.42$	$83.48\pm 0.65$	$94.63\pm 0.51$	$0.27\pm 0.15$
${\pi }_{\theta }$ (SFT-only)	$99.43\pm 0.49$	$99.57\pm 0.43$	$94.04\pm 0.85$	$95.24\pm 1.59$	$70.80\pm 1.08$	$91.33\pm 0.57$	$0.40\pm 0.10$
${\mathit{\pi }}_{\mathit{\theta }}^{\mathsf{\ast }}$ (SFT + GSPO)	$\mathbf{100.0}\pm 0.00$	$\mathbf{100.0}\pm 0.00$	$\mathbf{99.29}\pm 0.49$	$\mathbf{100.0}\pm 0.00$	$91.45\pm 0.85$	$\mathbf{97.83}\pm 0.20$	$\mathbf{0.00}\pm 0.00$

.

Experimental results indicate varying levels of proficiency among the evaluated models when handling the heterogeneous toolchain. While most models easily manage basic retrieval tasks ($T_{ret}$ and $T_{kg}$), noticeable disparities emerge in tasks requiring complex logic and strict physical constraints. Specifically, the Base model struggles with simulation evaluation ($T_{sim}$ accuracy falling below 50%) and exhibits a higher syntax error rate (SER), whereas advanced general models like Gemini-3.0-Flash and GLM-5 handle these challenges effectively with near-zero SERs. As for the dedicated execution models, ${\pi }_{\theta }$ (trained solely via SFT) noticeably reduces syntax errors compared to the Base model, yet its adaptation to high-dimensional simulation constraints remains a bottleneck, yielding only 70.80% on $T_{sim}$. The incorporation of GSPO effectively resolves this limitation: the optimized ${\pi }_{\theta }^{\mathsf{\ast }}$ not only elevates $T_{sim}$ execution to parallel the best general models but also achieves near-perfect performance across the computational tools ($T_{calc}$ and $T_{cost}$). Ultimately, by securing a 0.00% SER alongside the highest average accuracy of 97.83%, these findings suggest that the proposed ${\pi }_{\theta }^{\mathsf{\ast }}$ configuration establishes a reliable and robust execution foundation for the generative paradigm.

5. Conclusions

To resolve the conflict between ambiguous intents and strict physical constraints in UAV swarm task allocation, we propose a toolchain-augmented generative planning paradigm. This approach transitions task allocation from numerical fitting toward tool-verified semantic reasoning. Supported by a decoupled dual-model architecture and an execution-manifold-anchored training method, our framework utilizes the RCP algorithm to facilitate closed-loop tactical refinement via counterfactual deduction.

AFSIM-based experiments suggest that this holistic framework mitigates LLM physical hallucinations and gradient conflicts, facilitating a more reliable mapping from unstructured intents to physically compliant schemes. While validating the framework’s macro-level feasibility, we recognize its current reliance on idealized simulations. Consequently, our future work will focus on three key areas: (1) conducting fine-grained ablation studies to evaluate individual tool contributions; (2) bridging the sim-to-real gap by incorporating physical factors such as communication delays, sensing uncertainties, and real-time execution constraints; and (3) exploring the paradigm’s generalizability across broader mission profiles. Ultimately, this research offers a promising pathway for intelligent UAV swarm decision-making.