A multi-agent collaborative planning method and system for complex task decomposition

Abstract

This invention discloses a multi-agent collaborative planning method and system for complex task decomposition. The invention relates to the fields of multi-agent collaborative planning and distributed artificial intelligence technology, and includes the following steps: Step S1, constructing and updating in real-time a dynamic multi-dimensional capability state vector for each agent. This vector comprehensively represents the agent's overall capability state, including cognitive resource dimensions, communication resource dimensions, and physical resource dimensions. This multi-agent collaborative planning method and system for complex task decomposition effectively improves the accuracy and adaptability of complex task decomposition and allocation by establishing a dynamic multi-dimensional capability state vector and a multiple verification mechanism. This method can perceive changes in agent resource states in real time, ensuring that the task allocation scheme fully considers both global resource utilization efficiency and the real-time processing capabilities and load status of individual agents, thereby achieving continuously optimized collaborative planning in a dynamic environment.

Description

Technical Field

[0001] This invention relates to the fields of multi-agent cooperative planning and distributed artificial intelligence technology, specifically to a multi-agent cooperative planning method and system for complex task decomposition. Background Technology

[0002] In the field of multi-agent cooperative planning, task decomposition and resource allocation methods have significant limitations when facing dynamic and complex environments. Traditional systems typically rely on preset static rules or fixed optimization models for task scheduling, a mechanism that lacks necessary flexibility. When the computational load of agents surges, communication link quality fluctuates, or individual units fail during task execution, the predetermined allocation scheme cannot be adjusted effectively in real time, leading to a decline in overall system efficiency. A deeper problem lies in the difficulty of achieving a good balance between global resource optimization and autonomous response of individual agents.

[0003] While centralized scheduling can provide comprehensive planning, it suffers from high computational latency and cannot quickly respond to local changes. Conversely, a fully distributed strategy, while guaranteeing response speed, often leads to resource allocation conflicts and load imbalances due to the lack of a global perspective. Furthermore, current technologies often define "resources" for agents too narrowly, primarily considering computing power or time segments, while neglecting multidimensional and heterogeneous factors that constitute comprehensive capabilities, such as domain expertise, real-time communication bandwidth, and physical device power consumption. This results in a mismatch between task decomposition results and the agent's actual capabilities, ultimately affecting the quality and reliability of complex tasks. Therefore, the urgent problem to be solved is how to implement a collaborative planning mechanism that can dynamically perceive multidimensional resource states and adaptively decompose and allocate tasks based on this, thereby simultaneously ensuring both global system efficiency and the local responsiveness of individual units. Summary of the Invention

[0004] The purpose of this invention is to provide a multi-agent cooperative planning method and system for complex task decomposition, so as to solve the problems mentioned in the background art.

[0005] To address the aforementioned technical problems, this invention provides the following technical solution: a multi-agent cooperative planning method for complex task decomposition, comprising the following steps:

[0006] Step S1: Construct and update a dynamic multidimensional capability state vector for each agent in real time. This vector comprehensively represents the agent's overall capability state, including cognitive resource dimension, communication resource dimension, and physical resource dimension. The cognitive resource dimension covers the agent's historical success rate in handling specific task types and the weight of professional domain knowledge. The communication resource dimension includes communication latency and connection stability indicators between the agent and neighboring nodes. The physical resource dimension includes the agent's remaining battery power and computing load rate. A lightweight state monitor continuously collects the agent's operating data and dynamically adjusts the values ​​of each dimension of the vector to reflect the agent's real-time state changes.

[0007] Step S2: After receiving a complex task, the task decomposition engine performs joint optimization decomposition based on the current dynamic multidimensional capability state vector of the agent group. The decomposition process not only considers the logical sub-objectives of the task but also introduces real-time resource constraints to generate multiple alternative decomposition schemes. For each sub-task, a set of candidate agents is initially mapped. This mapping process performs the first screening by comparing the matching degree between the sub-task requirements and the agent capability vectors to exclude decomposition paths that are obviously incompatible with the global resource situation. For example, it avoids assigning sub-tasks with high communication requirements to agents with high communication latency.

[0008] Step S3: The preliminary mapping scheme is distributed to each agent. Each agent bids autonomously on the subtasks based on its local real-time state. The bid includes an accurate estimate of the execution cost and a confidence level of completion. After collecting all bids, the distributed negotiation module performs a second check to identify whether there are conflicts where multiple agents compete for the same subtask or some subtasks are not bid on. To resolve conflicts, a game theory-based negotiation mechanism is introduced. Agents engage in a limited number of rounds of bidding and counter-bidding interactions under the rules set by the coordinator. By incentivizing agents to expose their true capabilities and preferences, the allocation scheme is optimized and a draft allocation is generated.

[0009] Step S4: The allocation draft is submitted to the central coordinator for global consistency verification. The central coordinator quickly compares the draft with the latest global capability map and performs a third screening to check system-level load balancing and resource conflict risks. The verification focuses on avoiding excessive agent load or resource deadlock and ensuring the feasibility of the solution at the global level. After the verification is passed, the coordinator authorizes the final allocation solution to be executed.

[0010] Step S5: During the task execution phase, continuously monitor the actual performance data of the agent, including task completion progress and resource consumption; the monitoring data is fed back to the dynamic capability profile model in real time to adjust the capability parameters of the agent; when the performance deviation exceeds the preset threshold, trigger the task re-decomposition and allocation process to form a closed-loop adaptive optimization mechanism.

[0011] The above method achieves adaptive collaborative planning for complex task decomposition and resource allocation through a multi-stage iterative process, including the construction and updating of dynamic multidimensional capability state vectors, the first screening of task decomposition and resource pre-matching, the second verification of micro-negotiation and conflict resolution, the third screening of global consistency verification, and closed-loop feedback adjustment. This solves the balance problem between global resource optimization and real-time response of individual intelligent agents in dynamic environments.

[0012] Furthermore, the construction and updating of the dynamic multidimensional capability state vector specifically includes:

[0013] The cognitive resource dimension calculates the average success rate and knowledge adaptation coefficient by recording historical data of the agent's handling of various tasks. The knowledge adaptation coefficient is dynamically weighted according to the matching degree between the task type and the agent's professional domain. The communication resource dimension comprehensively evaluates the connection stability by periodically testing the data transmission rate and packet loss rate between the agent and neighboring nodes, and introduces a communication load factor to reflect the current network congestion status. The physical resource dimension obtains the agent's real-time power consumption rate and computing resource utilization rate through sensors or system interfaces, and normalizes them in combination with the estimated battery life.

[0014] The state monitor uses a data fusion algorithm to integrate the above-mentioned dimensional data into a unified vector. The values ​​of each dimension are smoothed through time series analysis to eliminate the impact of instantaneous fluctuations. The vector update frequency is adaptively adjusted according to the system dynamics, and the number of updates is increased during peak task execution periods to ensure that the vector accurately reflects the latest state of the agent.

[0015] Vector data is stored in a distributed database, supporting fast querying and real-time synchronization, and is called by the task decomposition engine and negotiation module; at the same time, vectors are designed as an extensible structure, allowing the addition of resource dimensions in the future without affecting the existing logic.

[0016] Furthermore, the joint optimization decomposition process of the task decomposition engine specifically includes:

[0017] The decomposition engine first performs semantic analysis on complex tasks to identify task dependencies and sub-objective priorities. Then, it incorporates dynamic multi-dimensional capability state vectors as hard or soft constraints into the decomposition algorithm and uses a multi-objective optimization method to generate alternative solutions. The optimization objectives include minimizing the overall execution time, balancing the agent's load, and maximizing the task success rate.

[0018] In the initial mapping phase, a matching score is calculated for each subtask and the candidate agent set. The matching score is based on the cosine similarity or Euclidean distance between the subtask requirements and the agent's capability vector. The first screening excludes agents with scores below the matching score by setting a matching score threshold, ensuring that only resource-compatible candidate sets are retained.

[0019] After evaluation of the alternative decomposition schemes, the scheme with the highest comprehensive evaluation is selected as the output. The evaluation indicators include resource utilization efficiency and scheme robustness. The entire process is accelerated by parallel computing to cope with large-scale intelligent agent environments.

[0020] Furthermore, the game theory-based negotiation mechanism specifically includes:

[0021] The negotiation mechanism is designed as a multi-round bidding process. In each round, the agent adjusts its bidding strategy based on its local state and global incentive signals. The incentive signals are issued by the coordinator and reflect the urgency and resource value of the sub-tasks.

[0022] The agent bidding behavior is based on a non-cooperative game model, where each agent attempts to maximize its own utility function, which comprehensively considers task benefits, execution costs, and resource consumption. The anti-bidding process allows agents to propose alternative solutions to competing subtasks, such as adjusting task order or resource allocation.

[0023] Conflict resolution is carried out through Nash equilibrium or Pareto optimality principles to ensure that the negotiation results satisfy both individual rationality and are close to global efficiency; the upper limit of the number of negotiation rounds is preset by the system to prevent infinite loops; finally, the negotiation module outputs a draft allocation, which undergoes a second test to ensure that the conflict rate is below the allowable level.

[0024] Furthermore, the global consistency verification process specifically includes:

[0025] The central coordinator maintains a global capability graph, which aggregates the dynamic multidimensional capability state vectors of all agents and marks system-level resource hotspots and potential bottlenecks. During verification, the allocation draft is compared with the graph topologically to check whether the agent load exceeds the capacity limit, whether the communication link is overloaded, and whether task dependencies form a cycle.

[0026] The verification algorithm uses graph traversal technology to identify resource conflicts and deadlock risks. For detected problems, the coordinator can locally adjust the draft, including reallocating high-load subtasks or inserting buffered tasks. The output of the third screening is the final solution that passes verification, or a modification suggestion is returned to the negotiation module.

[0027] The verification process emphasizes low latency and adopts an incremental update strategy, processing only the revised parts of the draft to maintain system real-time performance.

[0028] Furthermore, the closed-loop feedback adjustment mechanism specifically includes:

[0029] Monitoring data is collected through a distributed log system, including task execution time, resource utilization, and abnormal events; the feedback model uses machine learning algorithms to analyze the causes of performance deviations and dynamically adjust the agent's capability parameters.

[0030] Parameter adjustments include updating the weight coefficients and confidence levels of the capability vector. For example, when an agent successfully handles a certain type of task multiple times, its corresponding knowledge fit coefficient is increased; for agents with persistent deviations, a health assessment is triggered, and if necessary, the agent is marked as unusable.

[0031] The reallocation process is initiated only when the deviation is severe, and local or global replanning is performed by rolling back to step S2; the feedback cycle is adaptively set according to the system stability to ensure that the adaptive process is smooth and efficient.

[0032] Furthermore, regarding the machine learning algorithm parameters: In the closed-loop feedback adjustment mechanism, the machine learning algorithm used to update the agent's capability state vector employs stochastic gradient descent. Its key parameters are set as follows: the learning rate is initialized to a small positive value and uses an exponential decay strategy, gradually decreasing with each training iteration to ensure model convergence stability. The loss function used for training is defined as the mean squared error between the predicted value of the agent's capability vector and the actual observed task performance. After each fixed number of task cycles, the model performs a batch parameter update using all valid historical data collected during that period. Additionally, the agent's health score is calculated by a logistic regression model. The input features of this model include the agent's recent task failure rate, the standard deviation of response time, and abnormal fluctuations in resource consumption. Agents with health scores below a set threshold are temporarily isolated and no longer participate in task allocation.

[0033] Furthermore, the implementation of the method in a multi-agent system also includes system architecture components:

[0034] The system includes a task receiving module, a status monitoring module, a decomposition engine module, a negotiation module, a coordinator, and a feedback module; the modules communicate asynchronously through a message queue to ensure decoupling and scalability.

[0035] The task receiving module is responsible for parsing the input task and validating its format; the state monitoring module is deployed locally on each agent and is responsible for data collection and vector updates; the decomposition engine module and the negotiation module can be deployed in a distributed manner to share the computational load; the coordinator, as a lightweight central node, focuses on verification and authorization; the feedback module integrates monitoring and learning functions for continuous optimization; the inter-module interfaces adopt standardized protocols to support heterogeneous agent access, and the system is designed with a fault-tolerant architecture, so the failure of a single module does not affect the overall operation.

[0036] Furthermore, the data fusion algorithm for the dynamic multidimensional capability state vector further includes:

[0037] The algorithm employs Kalman filtering or Bayesian estimation methods to denoise and predict multi-source data; for the cognitive resource dimension, a sliding window model is introduced to calculate the historical success rate, with the window size adaptively adjusted according to the task frequency.

[0038] The assessment of communication resources combines real-time detection and historical statistics, and uses a weighted average method to calculate the comprehensive latency index; the power data of physical resources is predicted through a charge and discharge model to improve the accuracy of battery life.

[0039] Vector normalization uses minimum-maximum scaling or Z-score standardization to ensure that the values ​​of each dimension are comparable. At the same time, the algorithm supports dynamic weight allocation, and the weights are adjusted according to the task type and system strategy. For example, the weight of communication resources is increased in communication-intensive tasks.

[0040] Furthermore, the utility function of the game-theoretic negotiation mechanism specifically includes:

[0041] The utility function is a multivariate linear or nonlinear combination, with variables including task priority, agent capability matching degree, resource consumption cost, and expected benefit; the function parameters are optimized through offline training or online learning to adapt to different scenarios.

[0042] During the bidding process, the agent calculates the bid value based on the utility function and considers risk preferences; for example, a conservative agent may avoid tasks with high uncertainty. The coordinator influences the utility function by adjusting the incentive signals, guiding the agent's behavior toward the global goal.

[0043] The evaluation of the negotiation results adopts a social welfare function to ensure that the allocation draft reaches an acceptable level at both the individual and global levels; the mechanism also supports concurrent negotiation of multiple types of tasks and avoids resource contention through priority scheduling.

[0044] Furthermore, during the system initialization phase, each agent needs to establish its dynamic multidimensional capability state vector. This vector is constructed based on continuously monitored agent operational data, including historical records of task processing, real-time resource usage, and hardware status indicators. For cognitive capability assessment, the system records the success frequency of the agent in completing various tasks and analyzes the degree of matching between its professional domain and task type. Communication capability assessment involves periodically monitoring data transmission between the agent and surrounding nodes, comprehensively considering transmission latency and connection stability. Physical status monitoring includes collecting energy reserve information and computing resource usage data from the agent. All this data undergoes specialized fusion processing, employing a time-series-based smoothing method to eliminate the impact of instantaneous fluctuations, resulting in a stable and reliable capability assessment.

[0045] When the system receives a complex task, the task decomposition engine begins operation. First, it performs a structural analysis of the task, identifying the logical relationships and execution order between the subtasks. During decomposition, the engine simultaneously considers the current capabilities of all agents, taking resource availability as a crucial decision factor. The decomposition algorithm generates multiple possible decomposition schemes, each specifying in detail the division of subtasks and their correspondence with agents. In this process, the system performs an initial screening, comparing the matching degree between subtask requirements and agent capabilities to eliminate obviously unsuitable allocation combinations.

[0046] After initial decomposition, the system enters the negotiation phase. Each agent evaluates its assigned subtasks based on its real-time state, calculating the expected cost and probability of completion. These evaluation results are submitted to the negotiation module through bidding. This module checks for situations where multiple agents compete for the same task or where some tasks remain unclaimed. When such conflicts are detected, the system initiates a negotiation mechanism based on game theory. Agents adjust their bidding through multiple rounds of bidding, with each agent modifying its bidding strategy based on a balance between its own interests and the overall efficiency of the system. This process encourages agents to accurately reflect their capabilities and achieve an optimized allocation scheme through competition and cooperation.

[0047] The negotiated allocation draft then enters the global verification phase. The central coordinator compares the draft with the overall system state to check for issues such as uneven resource allocation or task dependency conflicts. The verification process focuses on the balance of agent workloads, communication link capacity limitations, and the rationality of task execution order. For any issues discovered, the coordinator can make local adjustments, such as reallocating some tasks or adjusting the execution order. The scheme that passes verification is authorized to execute and enters the actual operation phase.

[0048] During task execution, the system continuously monitors the actual performance of each agent. Monitoring data includes task completion progress, resource consumption, and records of abnormal events. This data is fed back to the system's evaluation module in real time to adjust the agent's capability parameters. When a significant deviation is detected between the agent's actual performance and expectations, the system decides whether to initiate a partial or complete replanning of the task, depending on the degree and scope of the deviation. This feedback mechanism enables the system to adapt to environmental changes and maintain efficient operation.

[0049] The entire system is implemented based on a modular architecture, with each functional module communicating through standardized interfaces. The task receiving module handles external input, the state monitoring module collects agent data, the decomposition engine analyzes tasks and generates allocation schemes, the negotiation module handles coordination between agents, the coordinator is responsible for global optimization, and the feedback module is responsible for performance evaluation and parameter adjustment. These modules can be deployed in a distributed manner, supporting the system's scalability and fault tolerance requirements.

[0050] The system achieves accurate characterization of agent states through dynamic capability assessment, ensures the feasibility of allocation schemes through multiple verification mechanisms, and realizes adaptive optimization of the system through closed-loop feedback. These technical features enable the system to effectively coordinate multiple agents to complete complex task decomposition and execution in complex dynamic environments, solving the problems of uneven resource allocation and untimely response.

[0051] A multi-agent cooperative planning system for complex task decomposition, the system being used to implement a multi-agent cooperative planning method for complex task decomposition, comprising:

[0052] The task receiving module is used to receive and parse complex task inputs;

[0053] The state monitoring module, deployed in each agent, is used to build and update dynamic multidimensional capability state vectors in real time.

[0054] The decomposition engine module is used to decompose tasks and pre-match resources based on dynamic multidimensional capability state vectors, and to perform the first screening.

[0055] The negotiation module is used to handle agent bidding and conflict resolution, and performs a second verification through a game theory mechanism;

[0056] The coordinator is used for global consistency verification and final authorization, and performs a third screening.

[0057] The feedback module is used to monitor task execution performance and adjust capability parameters to achieve closed-loop self-adaptation;

[0058] The modules are connected via a communication bus, and the data flow follows a multi-agent collaborative planning method for complex task decomposition. The system as a whole supports distributed deployment and elastic scaling.

[0059] This invention provides a multi-agent cooperative planning method and system for complex task decomposition. It has the following beneficial effects:

[0060] This multi-agent collaborative planning method and system for complex task decomposition effectively improves the accuracy and adaptability of complex task decomposition and allocation by establishing a dynamic multi-dimensional capability state vector and a multi-verification mechanism. The method can perceive changes in agent resource states in real time. Through triple guarantees of task decomposition pre-matching, distributed negotiation optimization, and global consistency verification, it ensures that the task allocation scheme fully considers both global resource utilization efficiency and the real-time processing capabilities and load conditions of individual agents, thereby achieving continuous optimization of collaborative planning in a dynamic environment.

[0061] This multi-agent collaborative planning method and system for complex task decomposition enhances the robustness and scalability of the multi-agent system through a modular architecture and closed-loop feedback mechanism. The collaborative work of each functional module enables the system to autonomously cope with uncertainties such as agent state fluctuations and changes in task requirements. While ensuring task completion quality, it improves the overall balance of system resource utilization, providing reliable technical support for multi-agent collaboration in complex scenarios. Attached Figure Description

[0062] Figure 1 This is a flowchart illustrating a multi-agent cooperative planning method for complex task decomposition according to the present invention.

[0063] Figure 2 This is a schematic diagram of the module interaction of a multi-agent collaborative planning system for complex task decomposition according to the present invention.

[0064] Figure 3 This is a state diagram of the game theory negotiation mechanism of the present invention. Detailed Implementation

[0065] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0066] Please see Figures 1 to 3This invention provides a technical solution: a multi-agent collaborative planning method for complex task decomposition, which achieves adaptive task allocation by establishing dynamic capability profiles and multiple verification mechanisms. First, the system constructs a dynamic multi-dimensional capability state vector for each agent. This vector is continuously updated and includes three key dimensions: cognitive resource dimension records the agent's historical performance and professional knowledge matching degree in handling specific tasks; communication resource dimension reflects the connection quality and network load status between the agent and surrounding nodes; and physical resource dimension monitors the agent's energy status and computing load level. These data are acquired in real time through a distributed acquisition module, and data fusion technology is used to eliminate instantaneous fluctuations, ensuring that the vector values ​​accurately reflect the agent's true state.

[0067] When the system receives a complex task, the task decomposition engine simultaneously considers the task's logical structure and the current system resource status for joint optimization. The decomposition process generates multiple feasible solutions, each containing a preliminary mapping relationship between subtasks and a set of candidate agents. At this stage, an initial screening is performed, comparing the degree of matching between subtask requirements and agent capability vectors to eliminate allocation schemes that clearly exceed the system's current processing capacity. For example, this avoids assigning computationally intensive tasks to agents already under high load.

[0068] After the initial plan is formed, the distributed negotiation phase begins. Each agent evaluates its assigned subtasks based on its local real-time state and submits bid data including execution costs and completion confidence. The negotiation module collects all bids and performs a second verification to identify and resolve task conflicts. Conflict resolution employs a game theory-based negotiation mechanism, where agents engage in multiple rounds of bidding under coordination rules, adjusting their bidding strategies to balance individual interests with overall system efficiency. This process encourages agents to accurately reflect their capabilities and generates an optimized allocation draft.

[0069] The proposed allocation is then submitted to the central coordinator for global consistency verification. The coordinator compares the draft with the latest system state, performing a third screening that focuses on checking system-level resource balance and potential conflict risks. The verification process focuses on key issues such as whether the agent workload is evenly distributed, whether task dependencies are reasonable, and whether communication links are overloaded. For any anomalies found, the coordinator may make local adjustments or require renegotiation. The approved solution is then authorized for execution.

[0070] During task execution, the system continuously monitors the actual performance of each agent, collecting operational data including task progress, resource consumption, and abnormal events. This data is fed back to the capability profile update module in real time to correct the agent's capability parameters. When performance deviations exceed the allowable range, the system initiates a replanning process to reassess the task allocation scheme. This closed-loop feedback mechanism ensures that the system can adapt to environmental changes and maintain a highly efficient and stable operating state.

[0071] The entire method achieves collaborative planning in dynamic environments by iteratively implementing five stages: dynamic capability assessment, task decomposition and pre-matching, distributed negotiation optimization, global verification and authorization, and continuous feedback adjustment. This ensures both efficient global resource utilization and consideration of the real-time state of individual agents. In particular, the triple verification mechanism ensures that the task allocation scheme is verified from multiple perspectives, effectively avoiding resource conflicts and uneven load distribution, and improving the system's robustness and adaptability in complex scenarios.

[0072] The construction and updating of dynamic multidimensional capability state vectors specifically includes:

[0073] The cognitive resource dimension calculates the average success rate and knowledge adaptation coefficient by recording historical data of the agent's handling of various tasks. The knowledge adaptation coefficient is dynamically weighted according to the matching degree between the task type and the agent's professional domain. The communication resource dimension comprehensively evaluates the connection stability by periodically testing the data transmission rate and packet loss rate between the agent and neighboring nodes, and introduces a communication load factor to reflect the current network congestion status. The physical resource dimension obtains the agent's real-time power consumption rate and computing resource utilization rate through sensors or system interfaces, and normalizes them in combination with the estimated battery life.

[0074] The state monitor uses a data fusion algorithm to integrate the above-mentioned dimensional data into a unified vector. The values ​​of each dimension are smoothed through time series analysis to eliminate the impact of instantaneous fluctuations. The vector update frequency is adaptively adjusted according to the system dynamics, and the number of updates is increased during peak task execution periods to ensure that the vector accurately reflects the latest state of the agent.

[0075] Vector data is stored in a distributed database, supporting fast querying and real-time synchronization, and is available for use by the task decomposition engine and negotiation module.

[0076] Further explanation is needed regarding the calculation rules for the knowledge fit coefficient: The knowledge fit coefficient is used to quantify the degree of matching between an agent's professional knowledge and a specific task type. The specific calculation rules are as follows: The system maintains a skill vector for each agent, which consists of multiple pairs of tuples, each representing a skill domain and its corresponding proficiency level. Simultaneously, each subtask is also parsed to generate a requirement vector, indicating its required skill domain. The knowledge fit coefficient is obtained by calculating the cosine similarity between the agent's skill vector and the task requirement vector. Specifically, only when the agent's proficiency level in a required skill domain exceeds a preset threshold is that skill domain considered a valid match. The final knowledge fit coefficient is a weighted sum of valid matches, and its value is normalized to between zero and one. This coefficient serves as a key weighting factor for the cognitive resource dimension in task allocation decisions.

[0077] It should be further explained that, in the specific implementation process, the system maintains a dynamic multi-dimensional capability state vector for each agent. Data on its cognitive resource dimension is obtained by analyzing the agent's historical task execution records. The system establishes independent success rate profiles for different types of tasks and calculates their average success rate within a certain time window. Simultaneously, based on the specific requirements of the current task to be decomposed, it matches the agent's built-in knowledge base or skill tags to dynamically generate a knowledge adaptation coefficient, which reflects the agent's expertise in a specific domain. The evaluation of the communication resource dimension relies on periodic network probing. The system measures data transmission latency and packet loss between the agent and other task-related nodes. Combining these indicators with current network topology information, a connection stability index is calculated. In addition, a communication load factor is introduced, which reflects the agent's current communication burden by monitoring the activity of the agent's network interface. Monitoring of the physical resource dimension is achieved by reading the agent's local hardware sensors or system performance interfaces, continuously acquiring its remaining battery percentage and CPU and memory utilization data, and estimating its sustainable operating time under the current load based on the agent's power consumption model.

[0078] All this multi-source heterogeneous data is collected by a lightweight state monitor, which uses data fusion algorithms to process the raw data. For example, time-series-based smoothing algorithms are used to filter out noise interference from instantaneous fluctuations, ensuring that the final generated vector values ​​can stably and accurately reflect the agent's true state. The vector update frequency is not fixed but adaptively adjusted according to the overall system operating state. For example, when the system detects a dense task queue or drastic environmental changes, it automatically increases the frequency of data collection and vector updates to ensure real-time planning. The processed vector data is stored in a distributed database that supports fast read, write, and querying, so that the task decomposition engine and subsequent negotiation modules can obtain the latest resource status information in a timely manner. The entire vector structure is designed with scalability in mind, allowing new resource evaluation dimensions to be added as needed in the future without major changes to the system's infrastructure. This design provides ample room for the system to cope with more complex planning scenarios in the future.

[0079] The joint optimization decomposition process of the task decomposition engine specifically includes:

[0080] The decomposition engine first performs semantic analysis on complex tasks to identify task dependencies and sub-objective priorities. Then, it incorporates dynamic multi-dimensional capability state vectors as hard or soft constraints into the decomposition algorithm and uses a multi-objective optimization method to generate alternative solutions. The optimization objectives include minimizing the overall execution time, balancing the agent's load, and maximizing the task success rate.

[0081] In the initial mapping phase, a matching score is calculated for each subtask and the candidate agent set. The matching score is based on the cosine similarity or Euclidean distance between the subtask requirements and the agent's capability vector. The first screening excludes agents with scores below the matching score by setting a matching score threshold, ensuring that only resource-compatible candidate sets are retained.

[0082] After evaluation of the alternative decomposition schemes, the scheme with the highest comprehensive evaluation is selected as the output. The evaluation indicators include resource utilization efficiency and scheme robustness. The entire process is accelerated by parallel computing to cope with large-scale intelligent agent environments.

[0083] It should be further explained that, in the specific implementation process, when a complex task is input into the system, the decomposition engine first performs deep semantic analysis to analyze the logical dependencies and execution order between the sub-objectives within the task, and determines the relative priority of each sub-objective accordingly. Subsequently, the decomposition engine incorporates the real-time acquired dynamic multi-dimensional capability state vectors of the agents as key constraints into the decision-making process of the decomposition algorithm. The real-time resource status represented by these vectors may serve as hard constraints that must be strictly followed, such as never assigning any sub-task to an agent whose computational load is already saturated; or it may serve as a flexible objective for optimization, such as prioritizing agents with better communication status to improve overall efficiency while meeting basic requirements.

[0084] Within this framework, the decomposition engine employs a multi-objective optimization approach. Its core objective is to comprehensively balance and strive to achieve multiple, sometimes conflicting, metrics. These metrics include, but are not limited to, minimizing the overall task execution time, balancing the workload across all agents, and maximizing the success rate of the entire task chain. This optimization process generates multiple logically and resource-allocated alternative decomposition schemes in parallel. For each generated scheme, the system calculates a matching score between each subtask and a set of candidate agents. This score is calculated based on the degree of fit between the subtask's explicitly stated resource requirements and the data in each dimension of the candidate agent's capability vector, evaluated using specific similarity metrics, such as calculating the directional similarity or distance between two vectors in multidimensional space.

[0085] Next, the system performs the first screening. This process is achieved by setting a reasonable lower threshold for the matching score. Any agent with a matching score below this threshold is considered to have a significant gap between its current capability state and the core requirements of the subtask, and is therefore excluded from the candidate set for that subtask. This mechanism can effectively filter out obviously unsuitable allocation options, such as avoiding assigning a subtask with extremely high real-time requirements to an agent with high current network latency, thereby preventing execution failures or performance bottlenecks that may be caused by resource mismatch from the source. After all the alternative solutions have undergone the above evaluation, the system will use a comprehensive evaluation function to rank them. This function takes into account the estimated resource utilization efficiency and robustness under different perturbation scenarios of each solution. Finally, the solution with the highest comprehensive evaluation is selected as the output and enters the subsequent process. To cope with the computational complexity brought about by a large-scale group of agents, the entire decomposition and optimization process is designed to support parallel computing to ensure the timeliness of the system response.

[0086] This refined decomposition and pre-matching mechanism ensures that the final task decomposition scheme is not only logically correct but also feasible in terms of resources, laying a reliable foundation for subsequent negotiation and execution. It is an important means to solve the coupling problem of resource optimization and task decomposition in dynamic environments.

[0087] Further explanation is needed regarding the selection and weight allocation of the multi-objective optimization algorithm: The task decomposition engine employs a non-dominated sorting genetic algorithm based on an elitist strategy. This algorithm is designed to handle multiple optimization objectives simultaneously, including minimizing the total task completion time, maximizing the overall task success rate, and minimizing the system's maximum load to achieve load balancing. Each optimization objective is assigned a dynamic weight, which is not fixed but initially set according to the system's global operating strategy and can be adjusted by the system administrator through a configuration interface. In each generation of the algorithm's evolution, the fitness value of the population is calculated, which is the weighted sum of the values ​​of each objective function. Through crossover, mutation, and selection operations, the algorithm progressively searches for the Pareto optimal solution set. Ultimately, the system selects the most balanced solution across all metrics from this optimal solution set as the output, ensuring that the decomposition scheme achieves comprehensive optimization across multiple key performance indicators.

[0088] Game theory-based negotiation mechanisms specifically include:

[0089] The negotiation mechanism is designed as a multi-round bidding process. In each round, the agent adjusts its bidding strategy based on its local state and global incentive signals. The incentive signals are issued by the coordinator and reflect the urgency and resource value of the sub-tasks.

[0090] The agent bidding behavior is based on a non-cooperative game model, where each agent attempts to maximize its own utility function, which comprehensively considers task benefits, execution costs, and resource consumption. The anti-bidding process allows agents to propose alternative solutions to competing subtasks, such as adjusting task order or resource allocation.

[0091] Conflict resolution is carried out through Nash equilibrium or Pareto optimality principles to ensure that the negotiation results satisfy both individual rationality and are close to global efficiency; the upper limit of the number of negotiation rounds is preset by the system to prevent infinite loops; finally, the negotiation module outputs a draft allocation, which undergoes a second test to ensure that the conflict rate is below the allowable level.

[0092] It should be further explained that, in the specific implementation process, after the initial mapping scheme generated by the task decomposition engine is distributed to each agent, the system initiates a structured multi-round bidding process. Before each round of bidding begins, the central coordinator broadcasts a set of incentive signals to all participating agents. These signals are not specific instructions, but rather reflect the relative urgency of each subtask in the current system state and the virtual resource value that can be obtained by completing the task, thus providing global guidance for the agents' autonomous decision-making. After receiving these signals, each agent, in conjunction with its latest local state, including real-time changing computing load, remaining power, and task-related specific skill proficiency, evaluates the subtask assigned to it. The agent internally calculates an execution cost estimate and forms a completion confidence level, encapsulating this information into bidding data and submitting it to the distributed negotiation module.

[0093] After collecting all bids, the negotiation module performs a second check, systematically identifying two types of key conflicts: first, multiple agents compete for the same preferred subtask considered to be of higher value or with lower resource consumption; second, some subtasks with higher resource consumption or poor placement receive no bids. To resolve these conflicts, the system introduces a decision-making framework based on a non-cooperative game model. Within this framework, each agent is designed as a rational decision-making entity whose behavioral objective is to maximize an internally defined utility function. This utility function is a multivariate combination, with inputs including the priority of the task itself transmitted through incentive signals, the match between the agent's capabilities and the task requirements, the resource consumption cost of executing the task, and the expected reward for successfully completing the task. Agents determine their bidding strategy based on the calculated utility function; for example, an agent with a lighter current workload might show a more aggressive bidding intention for tasks with higher rewards.

[0094] In the bidding and counter-bidding phases, agents do not communicate directly but interact indirectly through a negotiation module. For competitive optimization tasks, competitors can make new bids in a limited number of rounds under the rules set by the coordinator. These new bids can include better execution plans or lower resource demands. Essentially, this process transforms the system's global efficiency objective into a driving force influencing the agents' local decisions through incentive signals and utility functions. This encourages agents to naturally reveal their true capabilities and preferences in the pursuit of maximizing their own utility. The ultimate goal of conflict resolution is to bring the entire system to or near a stable state, i.e., Nash equilibrium, where no single agent can gain a higher return by unilaterally changing its bidding strategy. The total number of negotiation rounds is strictly controlled by a preset upper limit to prevent the negotiation process from falling into an infinite loop. Finally, the negotiation module outputs a draft allocation that has undergone secondary optimization and conflict resolution. This draft, while satisfying the reasonable interests of individual agents, also strives to approach the Pareto optimality of the system as a whole, effectively coordinating the decentralized autonomous decisions and moving them towards the global planning goal.

[0095] The global consistency verification process specifically includes:

[0096] The central coordinator maintains a global capability graph, which aggregates the dynamic multidimensional capability state vectors of all agents and marks system-level resource hotspots and potential bottlenecks. During verification, the allocation draft is compared with the graph topologically to check whether the agent load exceeds the capacity limit, whether the communication link is overloaded, and whether task dependencies form a cycle.

[0097] The verification algorithm uses graph traversal technology to identify resource conflicts and deadlock risks. For detected problems, the coordinator can locally adjust the draft, including reallocating high-load subtasks or inserting buffered tasks. The output of the third screening is the final solution that passes verification, or a modification suggestion is returned to the negotiation module.

[0098] The verification process emphasizes low latency and adopts an incremental update strategy, processing only the revised parts of the draft to maintain system real-time performance.

[0099] Further explanation is needed regarding the details of the graph traversal algorithm: During the global consistency verification phase, the system uses a depth-first search algorithm to check for dependencies and resource conflicts in the draft task allocation. The specific implementation details are as follows: The system models the task allocation scheme as a directed graph, where nodes represent agents and their current load states, and edges represent subtasks and their resource requirements and dependencies between tasks. The algorithm starts from any unvisited initial task node and recursively visits all its subsequent dependent tasks. During the traversal, the algorithm maintains a stack recording the accumulated load of agents on the current path. For each visited node, the algorithm checks whether the total load of the assigned agent exceeds its capacity limit after accepting the task, and checks for cycles in the task dependency chain. If any agent is found to be overloaded or has a circular dependency, the allocation path is marked as invalid. After completing the traversal of the entire graph, all paths not marked as invalid constitute the set of feasible solutions that have passed verification.

[0100] It should be further explained that, in the specific implementation process, the central coordinator maintains a dynamically updated global capability graph. This graph is not simply an aggregation of the state vectors of all agents, but a system-level resource topology model constructed through a specific algorithm. It clearly marks the resource hotspots, potential performance bottlenecks, and the load of communication links between agents in the current system. Upon receiving the allocation draft from the negotiation module, the verification process is immediately initiated. The coordinator performs a fine-grained topology comparison between the task allocation scheme in the draft and the global capability graph. This comparison aims to identify three core issues: First, checking whether any agent has been assigned a total task load exceeding the processing capacity limit indicated by its dynamic capability state vector; second, analyzing whether the data flow transmission requirements between tasks will cause the load on certain communication links to exceed their stable operating threshold; and third, detecting whether circular waiting, i.e., deadlock risk, has formed in the system due to dependencies between tasks.

[0101] To efficiently and comprehensively identify these potential problems, the verification algorithm employs an improved graph traversal technique. This technique abstracts the entire system model as a directed graph with resource weights, probing resource conflicts and logical deadlocks through specific search paths. For identified problems, the coordinator does not simply reject the entire draft, but possesses a degree of autonomous adjustment capability. For example, for detected overload of a single agent, the coordinator can reallocate one or more subtasks from its task list to other, less loaded, and equally capable backup agents; for detected communication link overload, relay tasks can be inserted into the data transmission path or the task execution order can be adjusted to stagger communication; for discovered circular dependency risks, a virtual buffer task can be introduced to break the cycle.

[0102] This verification constitutes the third screening. Its output has two possible outcomes: if the draft passes all checks or meets global consistency requirements after local adjustments, the coordinator authorizes the scheme as the final execution scheme; if the discovered problems cannot be effectively resolved through local adjustments, the coordinator returns specific modification suggestions along with the verification report to the negotiation module, triggering the next round of optimization negotiation. To ensure the system's responsiveness to external changes, this verification process is designed as a low-latency operation. The key lies in the use of an incremental update strategy, meaning that the coordinator does not recalculate the entire system state during each verification, but focuses on calculating and evaluating the changes in the current allocation draft compared to the previous version and their impact scope. This design allows the verification process to be completed within a reasonable time even in complex scenarios with a large number of agents, thus ensuring the practicality and real-time performance of the method in dynamic environments.

[0103] The closed-loop feedback adjustment mechanism specifically includes:

[0104] Monitoring data is collected through a distributed log system, including task execution time, resource utilization, and abnormal events; the feedback model uses machine learning algorithms to analyze the causes of performance deviations and dynamically adjust the agent's capability parameters.

[0105] Parameter adjustments include updating the weight coefficients and confidence levels of the capability vector. For example, when an agent successfully handles a certain type of task multiple times, its corresponding knowledge fit coefficient is increased; for agents with persistent deviations, a health assessment is triggered, and if necessary, the agent is marked as unusable.

[0106] The reallocation process is initiated only when the deviation is severe, and local or global replanning is performed by rolling back to step S2; the feedback cycle is adaptively set according to the system stability to ensure that the adaptive process is smooth and efficient.

[0107] It's important to further explain that during implementation, once a task enters the execution phase, the system continuously captures actual operational data from each agent node through a distributed log collection system. This data covers the actual execution time, the specific consumption rate of computing and communication resources, and records of various abnormal interruptions or performance failures. All this fine-grained operational data is aggregated in real time and transmitted to the system's feedback analysis module. This module incorporates specific machine learning algorithms, whose core task is not complex prediction, but rather focuses on analyzing the patterns and causes of deviations between the agent's actual performance and previous estimates. For example, the algorithm analyzes whether an agent's actual resource consumption consistently exceeds the initial estimate when handling a specific type of subtask, or whether its task completion success rate shows a trend change.

[0108] Based on these analytical results, the system dynamically adjusts the key parameters in the dynamic multidimensional capability state vector of the corresponding agent. This adjustment is targeted: if an agent is proven to have repeatedly and efficiently completed a certain type of task successfully, the system will appropriately increase the corresponding knowledge adaptation coefficient or historical success rate weight in its capability vector, giving it a higher priority in future similar task allocations. Conversely, for an agent whose actual communication latency is consistently higher than its reported value, the system will lower its score in the communication resource dimension to accurately reflect its true capabilities. In addition, the system maintains a hidden health score for each agent. When an agent exhibits a sustained and significant performance deviation, its health score will be lowered; when the score falls below a certain set warning threshold, the system will temporarily mark the agent as "unavailable," preventing it from participating in new task allocations until its performance recovers and it is reactivated after evaluation.

[0109] The reassignment process follows a prudent approach: the system sets permissible deviation thresholds for various performance metrics. The reassignment process is only triggered when monitored deviations consistently exceed these thresholds and, after analysis, are confirmed to be not temporary fluctuations. This process operates in two modes based on the severity and scope of the problem: if the problem is limited to a few agents or a local task chain, the system may initiate only local reassignment, reallocating the affected subtasks; if the system detects a global performance degradation or significant environmental change, it will initiate global reassignment, reverting to the initial steps of task decomposition. The entire feedback adjustment cycle is not fixed but dynamically adaptively set based on the overall system stability. When the system is running smoothly with minimal deviations, the feedback cycle is appropriately extended to reduce computational overhead; conversely, when the system is unstable or under high load, the feedback cycle is shortened to enable more intensive monitoring and faster adaptation. This ingenious design ensures that the entire closed-loop system maintains high adaptability and robustness to dynamic environments while keeping operating costs low.

[0110] The implementation of the method in a multi-agent system also includes system architecture components:

[0111] The system includes a task receiving module, a status monitoring module, a decomposition engine module, a negotiation module, a coordinator, and a feedback module; the modules communicate asynchronously through a message queue to ensure decoupling and scalability.

[0112] The task receiving module is responsible for parsing the input task and validating its format; the state monitoring module is deployed locally on each agent and is responsible for data collection and vector updates; the decomposition engine module and the negotiation module can be deployed in a distributed manner to share the computational load; the coordinator, as a lightweight central node, focuses on verification and authorization; the feedback module integrates monitoring and learning functions for continuous optimization; the inter-module interfaces adopt standardized protocols to support heterogeneous agent access, and the system is designed with a fault-tolerant architecture, so the failure of a single module does not affect the overall operation.

[0113] It should be further explained that, in the specific implementation process, the multi-agent collaborative planning system begins with the task receiving module. This module is responsible for parsing the format and validating the validity of complex tasks input from the outside, ensuring that the task instructions conform to the system's preset specifications, thus laying the foundation for subsequent processing. Following closely is the state monitoring module, which is deployed locally on each agent in a distributed manner. Its core responsibility is to continuously collect the agents' operational data and, based on this, construct and update in real time the crucial dynamic multi-dimensional capability state vector, thereby providing the system with the "sensory perception" of resource status.

[0114] The verified task instructions and the real-time updated capability state vector are fed into the decomposition engine module. This module is the central embodiment of the system's intelligence. Based on the acquired global resource information, it performs joint optimization decomposition and initial screening to generate a preliminary task allocation scheme that is both logically sound and resource-feasible. This scheme is then distributed to the negotiation module, which is typically deployed in a distributed manner to share the computational burden. It is responsible for performing game theory-based micro-negotiation and a second verification, handling bidding and conflicts between agents, and forming an optimized allocation draft.

[0115] The proposed allocation was then submitted to the coordinator. This module, acting as a lightweight central node, was designed not for heavy computation, but rather to focus on performing global consistency verification and a third screening. It utilizes its maintained global capability graph to conduct a rapid and crucial final review of the draft, ultimately authorizing the verified solutions to proceed to the execution phase. Throughout the task execution, the feedback module continuously operates, collecting performance data and analyzing and learning based on the closed-loop feedback adjustment mechanism. It dynamically adjusts the agent's capability parameters or triggers replanning when necessary, thus forming a complete, adaptive closed loop.

[0116] All these functional modules do not exist in isolation; they communicate asynchronously through a unified message queue. This design achieves decoupling between modules, meaning that upgrades or changes to any module will not directly affect other modules. It also provides the system with excellent horizontal scalability, adapting to load changes caused by an increase in the number of agents. The interfaces between modules follow standardized protocols, ensuring that heterogeneous agents of different types and manufacturers can be seamlessly integrated into the system and work collaboratively. Furthermore, the entire system architecture was designed with fault tolerance in mind from the outset. Through redundancy and fault detection mechanisms, it ensures that temporary failures of a single module will not paralyze the entire system, thus guaranteeing the continuity and reliability of complex task planning processes.

[0117] The data fusion algorithm for dynamic multidimensional capability state vectors further includes:

[0118] The algorithm employs Kalman filtering or Bayesian estimation methods to denoise and predict multi-source data; for the cognitive resource dimension, a sliding window model is introduced to calculate the historical success rate, with the window size adaptively adjusted according to the task frequency.

[0119] The assessment of communication resources combines real-time detection and historical statistics, and uses a weighted average method to calculate the comprehensive latency index; the power data of physical resources is predicted through a charge and discharge model to improve the accuracy of battery life.

[0120] Vector normalization uses minimum-maximum scaling or Z-score standardization to ensure that the values ​​of each dimension are comparable. At the same time, the algorithm supports dynamic weight allocation, and the weights are adjusted according to the task type and system strategy. For example, the weight of communication resources is increased in communication-intensive tasks.

[0121] It should be further explained that, in the specific implementation process, during the data preprocessing stage, the system employs Kalman filtering or Bayesian estimation methods for in-depth processing of the raw monitoring data obtained from the various components of the agent. These methods can effectively distinguish between normal information and random noise in the data and predict short-term trends in resource changes, thereby providing a more stable and forward-looking data foundation for state assessment.

[0122] In processing the cognitive resource dimension, the algorithm introduces a sliding window model to calculate the historical success rate. The size of this window is not fixed but dynamically adjusted according to the frequency of task submissions. When the system detects a dense number of task submissions, it automatically reduces the window size to improve the sensitivity and real-time performance of the evaluation; conversely, when the task intervals are long, it expands the window accordingly to ensure that the evaluation results have sufficient statistical significance. This adaptive mechanism ensures that reasonable evaluation results are obtained under different workloads.

[0123] For the evaluation of communication resources, the algorithm employs a weighted average method to comprehensively process real-time probe data and historical statistical information. Real-time probes provide a snapshot of the network state at the current moment, while historical data reflects the stability characteristics of the network state. The algorithm dynamically adjusts the weight ratio of real-time and historical data according to the degree of fluctuation in the network environment, increasing the reference value of historical data when the environment is stable, and placing more emphasis on real-time probe results when the environment changes drastically. This dynamic weighting strategy ensures that the evaluation results reflect both the instantaneous state and long-term performance.

[0124] In terms of physical resources, particularly in power prediction, the algorithm combines a specific power consumption model of the agent for comprehensive analysis. This model considers the typical power consumption characteristics of the agent under different operating modes, as well as factors such as battery aging, making the prediction of remaining battery life more closely reflect actual usage.

[0125] In the data normalization process, the system selects an appropriate standardization method based on the data distribution characteristics. For relatively uniformly distributed data, the min-max scaling method is used, while for datasets that may contain outliers, Z-score standardization is employed to ensure that data across all dimensions are compared and processed on a uniform scale.

[0126] In particular, the algorithm supports dynamic allocation of weights across various dimensions. The weight allocation strategy considers not only the characteristics of the task type but also the overall system operation strategy. For example, when performing communication-intensive tasks, the system automatically increases the weight coefficient of the communication resource dimension; while when performing computationally intensive tasks, it correspondingly increases the weight of the dimension representing computational capability. This dynamic weighting mechanism ensures that resource evaluation remains highly relevant to the current task requirements.

[0127] The entire data fusion process involves multi-level processing and verification, ultimately generating a state vector that accurately reflects the agent's comprehensive capabilities. This vector not only describes the agent's current state but also includes reasonable predictions of future states, providing solid data support for the system's task decomposition and resource allocation decisions. This refined data processing approach effectively solves the problems of one-sided and static resource assessment, and is a crucial technical guarantee for achieving accurate resource matching and dynamic adaptive planning.

[0128] The utility function of a game-theoretic negotiation mechanism specifically includes:

[0129] The utility function is a multivariate linear or nonlinear combination, with variables including task priority, agent capability matching degree, resource consumption cost, and expected benefit; the function parameters are optimized through offline training or online learning to adapt to different scenarios.

[0130] During the bidding process, the agent calculates the bid value based on the utility function and considers risk preferences; for example, a conservative agent may avoid tasks with high uncertainty. The coordinator influences the utility function by adjusting the incentive signals, guiding the agent's behavior toward the global goal.

[0131] The evaluation of the negotiation results adopts a social welfare function to ensure that the allocation draft reaches an acceptable level at both the individual and global levels; the mechanism also supports concurrent negotiation of multiple types of tasks and avoids resource contention through priority scheduling.

[0132] It should be further explained that, in the specific implementation process, the utility function of the game theory negotiation mechanism is constructed as a multivariate mathematical combination. Its input variables are carefully selected to comprehensively characterize the decision-making situation. These variables include the global task priority conveyed by the coordinator through incentive signals, ensuring that high-priority tasks receive more attention; the matching degree between the agent's own capability state and the specific requirements of the sub-task, which prompts the task to flow to the most suitable executor; the resource consumption costs incurred by the agent to complete the task, such as computation cycles, energy consumption, and communication bandwidth usage; and the expected reward obtained after successfully completing the task, which is positively correlated with the task priority and complexity. The specific form of the function can be a linear weighted sum or a nonlinear expression designed according to the system complexity to better capture the interactive effects between variables.

[0133] To adapt the utility function to different application scenarios and system goals, its internal parameters are not fixed but can be optimized through two main approaches: first, offline training using historical task data to fine-tune the parameters so that the function behaves as expected; second, continuous fine-tuning through online learning algorithms during system operation to adapt to environmental changes. In the bidding process, each agent calculates the utility value of each available task based on its current state and forms a bid accordingly. The agent's decision is also influenced by its inherent risk preference. For example, a conservative agent, even with a potentially substantial expected return, may exhibit a lower willingness to bid on tasks with high uncertainty in their outcome to avoid potential losses. Conversely, an aggressive agent is more willing to take on such tasks.

[0134] The coordinator acts as a guide in this process, indirectly influencing the utility function calculation results of each agent by dynamically adjusting the incentive signals issued to all agents. When the coordinator wants to improve the allocation efficiency of a key task, it can increase the incentive signal for that task, thereby directly increasing the utility value of all agents when calculating that task and encouraging more agents to participate in the competition. After negotiation, the system uses a global social welfare function to evaluate the overall quality of the allocation draft. This function comprehensively considers the individual utility of all agents and the overall goal completion of the system, ensuring that the final allocation scheme is not one that only benefits a few agents, but rather one that, while respecting individual rationality, is as close as possible to the Pareto optimal state of the system. That is, under the current conditions, it is difficult to increase the utility of a certain agent by adjusting the allocation without harming the interests of other agents or the overall interests of the system.

[0135] Furthermore, this negotiation mechanism is designed to support concurrent negotiation among multiple types of tasks. To avoid resource contention caused by excessive occupation by a few tasks, the system introduces a task priority-based scheduling mechanism. High-priority tasks have priority in the negotiation process, ensuring that critical tasks can be allocated quickly. This refined utility function and negotiation management mechanism together constitute the key technical support for effectively coordinating dispersed individual decisions and moving them towards a complex global planning goal.

[0136] A multi-agent cooperative planning system for complex task decomposition, the system being used to implement a multi-agent cooperative planning method for complex task decomposition, comprising:

[0137] The task receiving module is used to receive and parse complex task inputs;

[0138] The state monitoring module, deployed in each agent, is used to build and update dynamic multidimensional capability state vectors in real time.

[0139] The decomposition engine module is used to decompose tasks and pre-match resources based on dynamic multidimensional capability state vectors, and to perform the first screening.

[0140] The negotiation module is used to handle agent bidding and conflict resolution, and performs a second verification through a game theory mechanism;

[0141] The coordinator is used for global consistency verification and final authorization, and performs a third screening.

[0142] The feedback module is used to monitor task execution performance and adjust capability parameters to achieve closed-loop self-adaptation;

[0143] The modules are connected via a communication bus, and the data flow follows a multi-agent collaborative planning method for complex task decomposition. The system as a whole supports distributed deployment and elastic scaling.

[0144] It should be further explained that, in the specific implementation process, a multi-agent collaborative planning system for complex task decomposition begins with a task receiving module. This module, as the interface between the system and the external environment, is responsible for receiving the original complex task, performing structured decomposition and semantic parsing, verifying the completeness and standardization of task elements, and providing qualified input for subsequent processing. The state monitoring module is deployed in a distributed manner on each agent node in the network. Its core function is to continuously collect local data reflecting the comprehensive state of the agents, and, based on data fusion and update algorithms, construct and maintain the crucial dynamic multi-dimensional capability state vector, thereby providing the entire system with real-time and accurate resource situational awareness.

[0145] The parsed task information and the real-time updated capability state vector are synchronously transmitted to the decomposition engine module. This module carries the core decision-making logic of the system. It strictly follows the joint optimization decomposition process, combining the task logic structure with real-time resource constraints, performing the first screening, and generating a preliminary task allocation scheme that is feasible at both the logical and resource levels. This scheme is then distributed to the negotiation module, which is also deployed in a distributed manner. This module is responsible for implementing a game theory-based micro-negotiation mechanism, processing the bids submitted by each agent based on local state and utility function calculations, performing a second verification to resolve conflicts, and outputting an optimized allocation draft.

[0146] The draft was then submitted to the coordinator. This module, a key component ensuring the system's global stability, is designed to be lightweight and efficient, focusing on performing global consistency verification and a third screening. It utilizes its maintained global capability graph to conduct a rapid and rigorous final review of the draft and authorizes verified solutions to proceed to the execution phase. Throughout the task execution lifecycle, the feedback module continuously operates, collecting execution performance data through a distributed log system and dynamically correcting the agent's capability parameters based on a closed-loop feedback adjustment mechanism. It may also trigger a replanning process when performance deviations exceed limits, thus forming a complete, self-evolving adaptive control loop.

[0147] These six functional modules do not operate in isolation; they exchange data and transmit commands asynchronously through a unified, highly available communication bus. This message-based asynchronous communication architecture decouples the functions between modules, meaning that upgrades, replacements, or expansions of any module can be performed independently, greatly enhancing the system's maintainability and scalability. All module interfaces adhere to predefined standardized data protocols, ensuring seamless integration of heterogeneous intelligent agents from different vendors with varying capabilities, achieving true open collaboration. Furthermore, the overall system architecture incorporates built-in fault-tolerance mechanisms, such as module redundancy, heartbeat detection, and failover strategies, ensuring that temporary failures of a single module do not cause service interruptions to the entire system. This guarantees the continuity and high reliability of complex task planning processes in dynamic and uncertain environments, fully implementing the aforementioned methods.

[0148] It should be further explained that during the system initialization phase, each agent needs to establish its dynamic multidimensional capability state vector. This vector is constructed based on continuously monitored agent operational data. Specifically, for agent i, its capability state vector can be represented as V. i =(C i N i ,P i ), where C i N represents the cognitive ability dimension. i P represents the communication capability dimension. i Represents the physical state dimension.

[0149] Cognitive Ability Dimension C i The calculation method is as follows: C i =α·S i +β·K i ;

[0150] Where S i K represents the historical success rate of an agent in handling tasks, obtained by statistically analyzing the agent's task completion rates over the most recent T time periods. i This represents the degree of matching between the agent's professional knowledge and the current task, calculated by analyzing the similarity between task requirements and the agent's skill tags; α and β are weighting coefficients, satisfying α+β=1.

[0151] Communication capability dimension N i The calculation method for N is as follows: i =γ·L i +δ·B i ;

[0152] Where L i B represents the average communication latency between the agent and task-related nodes, obtained through periodic network probing; iThis represents the connection stability index, calculated by statistically analyzing the packet loss rate per unit time; γ and δ are weighting coefficients, satisfying γ+δ=1.

[0153] Physical state dimension P i The calculation method for P is as follows: i =ε·E i +ζ·R i ;

[0154] Where E i The remaining energy level of the agent is represented by reading data from hardware sensors; R i This represents the utilization rate of computing resources, calculated by monitoring CPU and memory usage; ε and ζ are weighting coefficients, satisfying ε+ζ=1.

[0155] When the system receives a complex task, the task decomposition engine begins to work. The objective function for task decomposition can be expressed as: ;

[0156] Where n represents the number of subtasks after decomposition, t j c represents the estimated execution time of subtask j. j R represents the cost of resource consumption. j The values ​​w1, w2, and w3 represent the risk of task failure and are weighting coefficients.

[0157] During the task allocation phase, the matching score of agent i to subtask j is calculated using the following formula:

[0158] ;

[0159] Where D j Let represent the requirement vector for subtask j, · represent the vector dot product, and ||·|| represent the magnitude of the vector.

[0160] The utility function for the negotiation phase is: U ij =θ1·P j +θ2·M ij -θ3·C ij +θ4·B j ;

[0161] Where U represents the total utility value of the agent in performing this subtask, and P j Indicates task priority, M ij C represents the matching degree. ij B represents the execution cost. j This represents the expected return, and θ1 to θ4 are adjustment parameters.

[0162] The consistency check function used in the global verification phase is:

[0163] ;

[0164] Where m represents the number of agents, L i L represents the load of agent i. avg This represents the average load. When the Consistency value exceeds a preset threshold, a redistribution mechanism is triggered.

[0165] During the feedback adjustment phase, the formula for updating the capability vector is:

[0166] ;

[0167] Where η is the learning rate parameter. This represents the capability vector calculated based on actual performance.

[0168] The system also includes task reassignment trigger conditions:

[0169] if(|t actual -t predict |>Δt max )or(S i min Thentrigger reallocation ();

[0170] Where t actual t represents the actual execution time. predict Indicates the prediction time, Δt max For the maximum allowable time deviation, S i S represents the current success rate. min This represents the minimum success rate requirement.

[0171] The above formulas and algorithms together constitute the core technical solution of the system, ensuring the effective implementation of multi-agent collaborative planning. All parameters have been experimentally verified to determine their reasonable value ranges, and the corresponding parameters can be adjusted according to specific application scenarios.

[0172] By establishing a dynamic multidimensional capability state vector and a multi-verification mechanism, the accuracy and adaptability of complex task decomposition and allocation are effectively improved. This method can perceive changes in the resource state of agents in real time. Through the triple guarantee of task decomposition pre-matching, distributed negotiation optimization, and global consistency verification, it ensures that the task allocation scheme fully considers both the global resource utilization efficiency and the real-time processing capacity and load status of individual agents, thereby achieving continuous optimization of collaborative planning in a dynamic environment.

[0173] ​By employing a modular architecture and closed-loop feedback mechanism, the robustness and scalability of the multi-agent system are enhanced. The collaborative work of each functional module enables the system to autonomously cope with uncertainties such as agent state fluctuations and changes in task requirements. While ensuring the quality of task completion, it also improves the overall balance of system resource utilization, providing reliable technical support for multi-agent collaboration in complex scenarios.

[0174] It should be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0175] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A multi-agent cooperative planning method for complex task decomposition, characterized in that, Includes the following steps: Step S1: Construct and update the dynamic multidimensional capability state vector of each agent in real time. This vector comprehensively represents the overall capability state of the agent, including cognitive resource dimension, communication resource dimension and physical resource dimension. Continuously collect the agent's operation data through a lightweight state monitor and dynamically adjust the values ​​of each dimension of the vector to reflect the real-time state changes of the agent. Step S2: After receiving a complex task, the task decomposition engine performs joint optimization decomposition based on the current dynamic multidimensional capability state vector of the agent group. The decomposition process not only relies on the logical sub-goals of the task, but also introduces real-time resource constraints to generate multiple alternative decomposition schemes. For each subtask, a set of candidate agents is initially mapped. This mapping process performs the first screening by comparing the matching degree between the subtask requirements and the agent's capability vector, and eliminating those decomposition paths that are obviously incompatible with the global resource situation. Step S3: The preliminary mapping scheme is distributed to each agent. Each agent bids autonomously on the subtasks based on its local real-time state. The bid includes the estimated execution cost and the confidence level of completion. After collecting all bids, the distributed negotiation module performs a second check to identify whether there are conflicts such as multiple agents competing for the same subtask or some subtasks not being bid on. A game theory-based negotiation mechanism is introduced. Under the rules set by the coordinator, agents conduct a limited number of rounds of bidding and counter-bidding interactions. By incentivizing agents to expose their true capabilities and preferences, the allocation scheme is optimized and a draft allocation is generated. Step S4: The draft is submitted to the central coordinator for global consistency verification. The central coordinator quickly compares the draft with the latest global capability map and performs a third screening to check the system-level load balancing and resource conflict risks. The verification focuses on avoiding excessive agent load or resource deadlock and ensuring the feasibility of the solution at the global level. Once the verification is successful, the coordinator authorizes the execution of the final allocation plan; Step S5: During the task execution phase, continuously monitor the actual performance data of the agent, including task completion progress and resource consumption; the monitoring data is fed back to the dynamic capability profile model in real time to adjust the agent's capability parameters. When the performance deviation exceeds the preset threshold, the task is re-decomposed and reassigned, forming a closed-loop adaptive optimization mechanism.

2. The multi-agent cooperative planning method for complex task decomposition according to claim 1, characterized in that: The construction and updating of the dynamic multidimensional capability state vector specifically includes: The cognitive resource dimension calculates the average success rate and knowledge adaptation coefficient by recording historical data of the agent's handling of various tasks. The knowledge adaptation coefficient is dynamically weighted according to the matching degree between the task type and the agent's professional domain. The communication resource dimension comprehensively evaluates the connection stability by periodically testing the data transmission rate and packet loss rate between the agent and neighboring nodes, and introduces a communication load factor to reflect the current network congestion status. The physical resource dimension obtains the agent's real-time power consumption rate and computing resource utilization rate through sensors or system interfaces, and normalizes them in combination with the estimated battery life. The state monitor uses a data fusion algorithm to integrate the above-mentioned dimensional data into a unified vector. The value of each dimension is smoothed through time series analysis. The vector update frequency is adaptively adjusted according to the dynamics of the system, and the number of updates is increased during peak task execution periods to ensure that the vector accurately reflects the latest state of the agent. Vector data is stored in a distributed database, supporting fast querying and real-time synchronization, and is available for use by the task decomposition engine and negotiation module.

3. The multi-agent cooperative planning method for complex task decomposition according to claim 1, characterized in that: The joint optimization decomposition process of the task decomposition engine specifically includes: The decomposition engine first performs semantic analysis on complex tasks to identify task dependencies and sub-objective priorities. Then, it incorporates dynamic multi-dimensional capability state vectors as hard or soft constraints into the decomposition algorithm and uses a multi-objective optimization method to generate alternative solutions. The optimization objectives include minimizing the overall execution time, balancing the agent's load, and maximizing the task success rate. In the initial mapping phase, a matching score is calculated for each subtask and the candidate agent set. The matching score is based on the cosine similarity or Euclidean distance between the subtask requirements and the agent's capability vector. The first screening excludes agents with scores below the matching score by setting a matching score threshold, ensuring that only resource-compatible candidate sets are retained. After evaluation of the alternative decomposition schemes, the scheme with the highest comprehensive evaluation is selected as the output. The evaluation indicators include resource utilization efficiency and scheme robustness.

4. The multi-agent cooperative planning method for complex task decomposition according to claim 1, characterized in that: The game theory-based negotiation mechanism specifically includes: The negotiation mechanism is designed as a multi-round bidding process. In each round, the agent adjusts its bidding strategy based on its local state and global incentive signals. The incentive signals are issued by the coordinator and reflect the urgency and resource value of the sub-tasks. The agent bidding behavior is based on a non-cooperative game model, where each agent attempts to maximize its own utility function, which comprehensively considers task benefits, execution costs, and resource consumption. The anti-bidding process allows agents to propose alternative solutions to competing subtasks, such as adjusting task order or resource allocation. Conflict resolution is carried out through Nash equilibrium or Pareto optimality principles to ensure that the negotiation results satisfy both individual rationality and are close to global efficiency; the upper limit of the number of negotiation rounds is preset by the system to prevent infinite loops; finally, the negotiation module outputs the allocation draft.

5. A multi-agent cooperative planning method for complex task decomposition according to claim 1, characterized in that: The global consistency verification process specifically includes: The central coordinator maintains a global capability graph, which aggregates the dynamic multidimensional capability state vectors of all agents and marks system-level resource hotspots and potential bottlenecks. During verification, the allocation draft is compared with the graph topologically to check whether the agent load exceeds the capacity limit, whether the communication link is overloaded, and whether task dependencies form a cycle. The verification algorithm uses graph traversal techniques to identify resource conflicts and deadlock risks. For detected problems, the coordinator can locally adjust the draft, including reallocating high-load subtasks or inserting buffered tasks. The output of the third screening is the final solution that passes verification, or a modification suggestion is returned to the negotiation module.

6. A multi-agent cooperative planning method for complex task decomposition according to claim 1, characterized in that: The closed-loop feedback adjustment mechanism specifically includes: Monitoring data is collected through a distributed log system, including task execution time, resource utilization, and abnormal events; the feedback model uses machine learning algorithms to analyze the causes of performance deviations and dynamically adjust the agent's capability parameters. Parameter adjustment includes updating the weight coefficients and confidence levels of the capability vector; for agents with persistent bias, a health assessment is triggered, marking them as unusable. The reallocation process is initiated only when the deviation is severe, performing local or global replanning by rolling back to step S2.

7. A multi-agent cooperative planning method for complex task decomposition according to claim 1, characterized in that: The implementation of the method in a multi-agent system also includes system architecture components: The system includes a task receiving module, a status monitoring module, a decomposition engine module, a negotiation module, a coordinator, and a feedback module; the modules communicate asynchronously through a message queue. The task receiving module is responsible for parsing the input task and validating its format; the state monitoring module is deployed locally on each agent and is responsible for data collection and vector updates; the decomposition engine module and the negotiation module can be deployed in a distributed manner to share the computational load; the coordinator, as a lightweight central node, focuses on verification and authorization. The feedback module integrates monitoring and learning functions for continuous optimization; the interfaces between modules adopt standardized protocols to support the access of heterogeneous intelligent agents.

8. A multi-agent cooperative planning method for complex task decomposition according to claim 2, characterized in that: The data fusion algorithm for the dynamic multidimensional capability state vector further includes: The algorithm employs Kalman filtering or Bayesian estimation methods to denoise and predict multi-source data; for the cognitive resource dimension, a sliding window model is introduced to calculate the historical success rate, with the window size adaptively adjusted according to the task frequency. The assessment of communication resources combines real-time detection and historical statistics, and uses a weighted average method to calculate the comprehensive delay index; the power data of physical resources is predicted through a charge and discharge model. Vector normalization is performed using minimum-maximum scaling or Z-score standardization to ensure comparability of values ​​across dimensions. Simultaneously, the algorithm supports dynamic weight allocation, with weights adjusted based on task type and system strategy.

9. A multi-agent cooperative planning method for complex task decomposition according to claim 4, characterized in that: The utility function of the game-theoretic negotiation mechanism specifically includes: The utility function is a multivariate linear or nonlinear combination, with variables including task priority, agent capability matching degree, resource consumption cost, and expected benefit; the function parameters are optimized through offline training or online learning. During the bidding process, the agent calculates the bid value based on the utility function and takes risk preference into account; the coordinator influences the utility function by adjusting the incentive signals, guiding the agent's behavior toward the global goal; The evaluation of the negotiation results uses a social welfare function to ensure that the proposed distribution is acceptable at both the individual and global levels.

10. A multi-agent cooperative planning system for complex task decomposition, characterized in that, The system is used to implement the method as described in any one of claims 1 to 9, comprising: The task receiving module is used to receive and parse complex task inputs; The state monitoring module, deployed in each agent, is used to build and update dynamic multidimensional capability state vectors in real time. The decomposition engine module is used to decompose tasks and pre-match resources based on dynamic multidimensional capability state vectors, and to perform the first screening. The negotiation module is used to handle agent bidding and conflict resolution, and performs a second verification through a game theory mechanism; The coordinator is used for global consistency verification and final authorization, and performs a third screening. The feedback module is used to monitor task execution performance and adjust capability parameters to achieve closed-loop self-adaptation; The modules are connected via a communication bus.

Images