Task complexity driven graph semantic multi-agent collaborative decision-making method and system

Abstract

The application belongs to the field of natural language processing, and provides a task complexity driven graph semantic multi-agent collaborative decision method and system, acquires a task text to perform semantic coding to obtain a task semantic vector, performs evaluation based on the task semantic vector to obtain a complexity vector, and calculates a task complexity score of the complexity vector; fuses the task semantic vector and the complexity vector to obtain a task representation vector, constructs an agent capability relation graph, obtains a participation probability of each agent node according to the task representation vector and the agent capability relation graph, forms a dynamic agent combination scheme; performs task decomposition according to the agent combination scheme, constructs a subtask dependency graph, schedules the execution order of the subtasks through topological sorting, realizes the collaborative execution of the agents, and generates a task result. The application realizes the accurate matching and efficient cooperation of the agent combination, and significantly improves the ability of the multi-agent system to process complex tasks and the resource utilization efficiency.

Description

TECHNICAL FIELD

[0001] The present application belongs to the technical field of natural language processing, and particularly relates to a task complexity driven graph semantic multi-agent collaborative decision method and system. BACKGROUND

[0002] The statements in this section merely provide background information related to the present application and do not necessarily constitute prior art.

[0003] The current large language model (LLM) and multi-agent system (Multi-Agent System, MAS) are increasingly becoming a key research direction in intelligent task processing. In particular, in complex task scenarios, how to dynamically schedule multiple heterogeneous agents according to task requirements to collaboratively complete reasoning, tool invocation and influence system efficiency and task completion quality are the core bottlenecks.

[0004] Most traditional MAS architectures use fixed agent sets and static division strategies, which usually decompose tasks based on predefined rules or heuristic methods and statically assign them to different agents for execution. This static allocation method lacks modeling and dynamic optimization capabilities for task complexity, resource usage efficiency, and inter-agent capability redundancy. In processing large-scale, multi-variant complex instructions, it is easy to cause resource waste, uneven agent load or task response delay, etc., which seriously restricts the system scalability and actual application performance.

[0005] In recent years, some research work has attempted to introduce task feature driven scheduling optimization. For example, the ELIS system uses context length to predict task reasoning cost to optimize task queue ordering; the OmniNova framework realizes LLM routing and tool scheduling through task evaluation. However, these existing technologies only optimize scheduling at the computing power level, lacking deep modeling and learning mechanisms for MAS internal agent combination strategies. In the field of multi-agent scheduling, there are also researches (such as SALDAE) SALDAE framework starts from the alliance division scheme, and gradually splits / merges through the bridge path to find the optimal solution. However, the above methods often assume that the task complexity is known or can be manually specified, lacking an automatic and lightweight complexity modeling mechanism, making it difficult to adapt to real scenarios with complex task types and uncertain distribution.

[0006] In the actual multi-agent task execution process, the ability requirements of different sub-tasks for agents are significantly different. In the face of complex and diversified task inputs, the existing methods generally lack a joint optimization mechanism for deep modeling of task semantics and combination strategies, which leads to a series of technical problems, including waste of computing resources, unbalanced agent load, and rising task failure rate. Therefore, for a multi-agent system, due to the mismatch between agent combination and task complexity, the ability to handle complex tasks and the utilization rate of resources are low. SUMMARY

[0007] To solve the above problems, the present application provides a task complexity driven graph semantic multi-agent collaborative decision method and system. In the multi-agent framework, based on task complexity and graph structured agent relationship modeling, the appropriate agent combination is adaptively selected, and through task decomposition, agent collaborative execution and dynamic monitoring feedback, efficient task processing capability is realized.

[0008] According to some embodiments, the first aspect of the present application provides a task complexity driven graph semantic multi-agent collaborative decision method, which adopts the following technical scheme:

[0009] The task complexity driven graph semantic multi-agent collaborative decision method comprises:

[0010] Obtaining a task text for semantic encoding to obtain a task semantic vector, evaluating based on the task semantic vector to obtain a complexity vector, and calculating a task complexity score of the complexity vector;

[0011] Fusing the task semantic vector and the complexity vector to obtain a task representation vector, constructing an agent capability relationship graph, obtaining a participation probability of each agent node according to the task representation vector and the agent capability relationship graph, and forming a dynamic agent combination scheme;

[0012] According to the agent combination scheme, task decomposition is performed, a sub-task dependency graph is constructed, the execution order of the sub-tasks is scheduled through topological sorting, agent collaborative execution is realized, and a task result is generated.

[0013] Further, obtaining a task text for semantic encoding to obtain a task semantic vector, evaluating based on the task semantic vector to obtain a complexity vector, and calculating a task complexity score of the complexity vector, comprises:

[0014] Obtaining a task text for semantic encoding to obtain a task semantic vector;

[0015] Based on the task semantic vector, a complexity vector is obtained by predicting and evaluating from four dimensions of knowledge intensity, reasoning step number, tool dependency and interaction complexity;

[0016] The evaluation results of the four dimensions in the complexity vector are weighted and summed to obtain a task complexity score.

[0017] Further, the task semantic vector and the complexity vector are fused to obtain a task representation vector, and an agent capability relationship graph is constructed, including:

[0018] The task semantic vector and the complexity vector are fused to obtain a task representation vector.

[0019] Based on the capability description of the agent, a capability feature vector is obtained, the similarity between the capability feature vectors of the agents is determined to determine the relationship between the agents, and the agent capability relationship graph is constructed based on the relationship between the agents and the agents.

[0020] Further, the participation probability of each agent node is obtained based on the task representation vector and the agent capability relationship graph, and a dynamic agent combination scheme is formed, including:

[0021] An initial node feature matrix is constructed based on the agents and the capability feature vectors of the agents, and the initial node feature matrix is updated based on the agent capability relationship graph to obtain a node feature matrix.

[0022] The node feature matrix is processed using a multi-condition pooling mechanism to obtain an agent global graph representation.

[0023] The participation probability of each agent node is calculated based on the agent feature representation in the node feature matrix, the agent global graph representation, and the task representation vector.

[0024] The agent nodes that meet the selection threshold are retained to form a dynamic agent combination scheme.

[0025] Further, the task is decomposed based on the agent combination scheme, and a subtask dependency graph is constructed, including:

[0026] The task text is decomposed into a plurality of subtasks to obtain a subtask set.

[0027] Each subtask is taken as a subtask node, and the subtask node attributes include subtask description and estimated complexity score.

[0028] The dependency relationship probability between the subtasks is calculated based on the subtask description text, and when the dependency relationship probability exceeds the relationship probability threshold, a directed edge is created between the corresponding nodes, and all created directed edges are filtered to construct an initial subtask dependency graph.

[0029] The loop in the initial subtask dependency graph structure is traversed using a depth-first search, and the directed edge with the lowest dependency relationship probability in the loop is removed from the initial subtask dependency graph.

[0030] Until there is no loop in the initial subtask dependency graph, the subtask dependency graph is obtained.

[0031] Further, the execution order of the subtasks is scheduled by the topological sorting, the agent collaborative execution is realized, and the task result is generated.

[0032] All subtask nodes with an in-degree of 0 in the subtask dependency graph are identified to form a priority queue.

[0033] The subtask node with the highest priority in the priority queue is taken out and added to the execution sequence, and the in-degree of all successor nodes thereof is reduced.

[0034] When the in-degree of a certain successor node is reduced to 0, the successor node is added to the priority queue.

[0035] Until the priority queue is empty, the sorting of all subtask nodes is completed, and the final execution sequence is obtained.

[0036] For each subtask, the ability matching degree score of each agent is calculated, and the agent combination scheme subset is constructed with the agents whose ability matching degree scores exceed a set matching degree threshold.

[0037] Based on the agent combination scheme subset corresponding to each subtask, the subtasks are executed in the order in the final execution sequence, and the task result is generated.

[0038] According to some embodiments, the second scheme of the present application provides a task complexity driven graph semantic multi-agent collaborative decision system, which adopts the following technical scheme:

[0039] The task complexity driven graph semantic multi-agent collaborative decision system comprises:

[0040] A task complexity evaluation module is configured to obtain a task text, perform semantic encoding to obtain a task semantic vector, evaluate based on the task semantic vector to obtain a complexity vector, and calculate a task complexity score of the complexity vector.

[0041] An agent selection decision module is configured to fuse the task semantic vector and the complexity vector to obtain a task representation vector, construct an agent capability relationship graph, obtain a participation probability of each agent node according to the task representation vector and the agent capability relationship graph, and form a dynamic agent combination scheme.

[0042] An execution and feedback optimization module is configured to perform task decomposition according to the agent combination scheme, construct a subtask dependency graph, schedule the execution order of the subtasks by topological sorting, realize agent collaborative execution, and generate a task result.

[0043] According to some embodiments, the third scheme of the present application provides a computer readable storage medium.

[0044] A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method as described in the first scheme above.

[0045] According to some embodiments, a fourth aspect of the present invention provides a computer device.

[0046] A computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method as described in the first embodiment above.

[0047] According to some embodiments, a fifth aspect of the present invention provides a computer program product or computer program.

[0048] A computer program product or computer program includes computer instructions stored in a computer-readable storage medium, wherein a processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method as described in the first embodiment above.

[0049] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0050] This invention, through multi-dimensional complexity analysis of tasks, adaptively adjusts the agent selection strategy based on the cognitive, operational, interactive, and system complexity of the task. This solves the problem of mismatch between agent composition and task complexity in existing technologies, significantly improving the success rate and efficiency of task processing. Furthermore, it employs graph neural networks to model the complex relationships between agents, considering not only individual agent capabilities but also capturing relationships such as enhanced collaboration, complementary capabilities, overlapping capabilities, and conflict repulsion. This overcomes the limitations of existing technologies where agent selection is too independent and neglects synergistic effects, achieving a superior combination effect. Utilizing a multi-condition pooling global information aggregation method, a multi-condition pooling mechanism is designed. It comprehensively captures graph structure information through max pooling, average pooling, and attention pooling, focusing on both superior individual capabilities and overall synergistic effects, thus solving the problems of limited expressive power and singular global information aggregation in existing technologies.

[0051] This invention dynamically adjusts the agent selection threshold based on task complexity, enabling more agents to collaborate on complex tasks while keeping simple tasks streamlined to achieve adaptive selection of the dynamic threshold. This effectively solves the problems of fixed agent numbers and unreasonable resource utilization in existing technologies. By clarifying the execution order and dependencies between subtasks through a subtask dependency graph and combining it with a priority-based scheduling algorithm, structured task decomposition and scheduling are achieved, realizing efficient parallel execution of tasks and overcoming the shortcomings of coarse task decomposition and low execution efficiency in existing technologies. This invention monitors the execution status in real time, implementing a "use and release" resource management strategy, significantly improving system resource utilization and solving the problems of redundant resource occupation and idle agent waste in existing technologies. The system of this invention has a three-level response strategy, which can take corresponding adjustment measures according to the severity of anomalies, from fine-tuning parameters to reallocating agents, ensuring the reliability of task execution and making up for the shortcomings of simple and poorly robust anomaly handling mechanisms in existing technologies.

[0052] This invention achieves precise matching and efficient collaboration in agent selection through a complexity-driven agent selection strategy and relational representation using graph semantic modeling. This significantly improves the ability of multi-agent systems to handle complex tasks and enhances resource utilization efficiency, providing a novel technical solution for intelligent solutions to complex tasks. Attached Figure Description

[0053] The accompanying drawings, which form part of this invention, are used to provide a further understanding of the invention. The illustrative embodiments of the invention and their descriptions are used to explain the invention and do not constitute an improper limitation of the invention.

[0054] Figure 1 This is a flowchart of a task complexity-driven graph semantic multi-agent collaborative decision-making method in an embodiment of the present invention;

[0055] Figure 2 This is a flowchart of the task complexity analysis and evaluation stage in an embodiment of the present invention;

[0056] Figure 3 This is a flowchart of the graph semantic agent selection and decision-making stage in an embodiment of the present invention;

[0057] Figure 4 This is a flowchart of the task decomposition and collaborative execution phase in an embodiment of the present invention. Detailed Implementation

[0058] The present invention will be further described below with reference to the accompanying drawings and embodiments.

[0059] It should be noted that the following detailed description is illustrative and intended to provide further explanation of the invention. Unless otherwise specified, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention pertains.

[0060] It should be noted that the terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the scope of exemplary embodiments according to the invention. As used herein, the singular form is intended to include the plural form as well, unless the context clearly indicates otherwise. Furthermore, it should be understood that when the terms "comprising" and / or "including" are used in this specification, they indicate the presence of features, steps, operations, devices, components, and / or combinations thereof.

[0061] Where there is no conflict, the embodiments and features in the embodiments of the present invention can be combined with each other.

[0062] Example 1

[0063] like Figure 1 As shown, this embodiment provides a task complexity-driven graph semantic multi-agent collaborative decision-making method. This embodiment uses the application of this method to a server as an example for illustration. It is understood that this method can also be applied to terminals, and can also be applied to systems including terminals, servers, and other components, and implemented through interaction between the terminal and the server. The server can be an independent physical server, a server cluster composed of multiple physical servers, or a distributed system. It can also be a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network servers, cloud communication, middleware services, domain name services, CDN security services, and big data and artificial intelligence platforms. The terminal can be a smartphone, tablet, laptop, desktop computer, smart speaker, smartwatch, etc., but is not limited to these. The terminal and server can be directly or indirectly connected via wired or wireless communication, which is not limited herein. In this embodiment, the method includes the following steps:

[0064] Obtain the task text, perform semantic encoding to obtain the task semantic vector, evaluate based on the task semantic vector to obtain the complexity vector, and calculate the task complexity score of the complexity vector.

[0065] The task semantic vector and complexity vector are fused to obtain the task representation vector, and an agent capability relationship graph is constructed. Based on the task representation vector and the agent capability relationship graph, the participation probability of each agent node is obtained, forming a dynamic agent combination scheme.

[0066] Tasks are decomposed according to the agent composition scheme, a subtask dependency graph is constructed, and the execution order of subtasks is scheduled by topological sorting to achieve collaborative execution of agents and generate task results.

[0067] To address the problems existing in current multi-agent systems, such as lack of task complexity awareness in agent selection, insufficient modeling of relationships between agents, simple cooperation mechanisms, and low resource utilization, this embodiment provides a trainable agent allocation mechanism that supports multi-objective optimization. This mechanism can effectively combine task complexity assessment, semantic information extraction, and agent capability feature modeling to dynamically generate efficient multi-agent combination schemes, thereby achieving high-quality execution of complex tasks in resource-constrained application scenarios.

[0068] The method in this embodiment divides the processing of complex tasks in the agent framework into three key stages: task complexity assessment stage, graph semantic agent selection and decision-making stage, and task decomposition and collaborative execution stage.

[0069] The task complexity assessment phase is responsible for analyzing the semantic content of the task and quantifying its multidimensional complexity indicators. First, the natural language task is converted into a high-dimensional semantic vector through the task semantic understanding module. Then, the task complexity assessment module analyzes the complexity indicators of the task in four dimensions: cognition, operation, interaction, and system, providing a refined decision-making basis for subsequent agent combination.

[0070] The graph semantic agent selection decision-making stage is based on task requirements and complexity. It uses graph neural networks to model agent relationships and generate optimal combination schemes. First, the task representation fusion module integrates task semantic and complexity information. Then, the agent relationship construction module builds a capability relationship graph. Next, the agent relationship encoding module and the multi-condition pooling module extract graph structure features. Finally, the agent selection decision-making module dynamically generates agent combination schemes based on task requirements and complexity.

[0071] The task decomposition and collaborative execution phase organizes the selected agents to collaboratively complete the task. First, the task decomposition module breaks down the complex task into a structured subtask dependency graph (DAG). Then, the execution order between subtasks is determined, and subtasks are assigned to corresponding agents for collaborative execution based on capability matching, ultimately generating a complete task execution result. This three-phase design enables the system to form a complete process from task understanding and agent selection to task decomposition and execution, ensuring the effective handling of complex tasks.

[0072] Step S1: Obtain the task text and perform semantic encoding to obtain the task semantic vector. Based on the task semantic vector, evaluate to obtain the complexity vector and calculate the task complexity score of the complexity vector.

[0073] like Figure 2 As shown, in the task complexity analysis and evaluation stage, the method in this embodiment first receives the task text input by the user, and generates a task complexity score through semantic encoding and a complexity evaluation network. The specific steps are as follows:

[0074] Step S1.1: Obtain the task text and perform semantic encoding to obtain the task semantic vector. The process is as follows:

[0075] First, a Task Semantic Understanding Module (TSUM) is proposed. This module is responsible for converting task descriptions in natural language form into computer-processable semantic representations. This module employs, but is not limited to, a pre-trained BAAI / bge-large-en-v1.5 embedding model; other semantic encoding models can be selected as needed. It maps the task text into a 768-dimensional high-dimensional vector, effectively capturing the semantic information and implicit requirements of the task. It should be understood that the 768 dimensions mentioned here are just an example, and other dimensions can be selected as needed. For the input task text... Extract through this model Vector representation of the tag This serves as the task semantic vector. The encoding process can be represented as:

[0076]

[0077] in, express The forward computation process of the embedded model.

[0078] Step S1.2: Based on the task semantic vector, predict and evaluate the complexity vector from four dimensions: knowledge density, number of reasoning steps, tool dependence, and interaction complexity. Calculate the task complexity score based on the complexity vector, as follows:

[0079] This embodiment proposes a Task Complexity Assessment Module (TCAM), which employs a 6-layer residual-connected multilayer perceptron structure to map task semantic vectors into multidimensional complexity indices. TCAM extracts key features from the task semantic vectors and assesses the complexity of the task across four dimensions: cognition, operation, interaction, and system, providing crucial information for subsequent agent composition. TCAM consists of an input layer (768 dimensions), four hidden layers (512, 384, 256, and 128 dimensions respectively), and an output layer (4 dimensions). Each layer uses the LeakyReLU activation function (with a negative slope of 0.1), and residual connections are introduced to mitigate the vanishing gradient problem in deep networks. This deep structure design allows the network to extract abstract features of the task layer by layer, while residual connections ensure the integrity of information during deep transmission, significantly improving the accuracy and robustness of complexity assessment. The output layer uses linear activation to output a 4-dimensional complexity vector. The forward computation process of this network employs a residual structure, where... and These are the weight matrix and bias vector for each layer, respectively.

[0080] Complexity vector It contains four dimensions, each representing a different complexity feature of the task. This represents the knowledge density, with a value range of [0,1], reflecting the breadth and depth of domain knowledge required for the task; This represents the number of reasoning steps, with a value range of [1, 10], reflecting the estimated number of logical reasoning steps required to complete the task. Indicates tool dependency, with a value range of [0,1], reflecting the degree to which a task depends on external tools; This represents the interaction complexity, with a value range of [0,1], reflecting the possible interaction frequency between agents during task execution.

[0081] Based on the aforementioned 4-dimensional complexity vector, the task complexity score is calculated. This serves as an important basis for subsequent agent composition strategies. The calculation formula is:

[0082]

[0083] in, , , , is the weighting coefficient, representing the proportion of each dimension's contribution to the task complexity.

[0084] This embodiment employs a supervised learning method to train the task complexity evaluation module. For training dataset construction, two publicly available datasets, google / Synthetic-Persona-Chat and lmsys / chatbot_arena_conversations, are used as the base datasets. The dialogues in these datasets are processed to extract user queries as input tasks. A complexity vector and task complexity score are labeled for each task using LLM and heuristic rules.

[0085] The task complexity evaluation module in this embodiment uses weighted mean squared error (MSE) as the main loss function, and also introduces... Regularization is used to prevent overfitting; the loss function is defined as:

[0086]

[0087] Among them, the weighted mean square error The calculation formula is:

[0088]

[0089] The formula for calculating the regularization term is:

[0090]

[0091] Therefore, the complete loss function is:

[0092]

[0093] in, This is the complexity vector for prediction. This is the complexity vector of the actual annotation. and They represent the first The predicted complexity vector and the actual complexity vector in each dimension. For the loss weights of each dimension, The regularization coefficient is . For the task complexity evaluation module One parameter, This represents absolute value operations.

[0094] Through the above steps, this embodiment can accurately assess the complexity of the task, providing a reliable basis for the subsequent generation of agent combination strategies.

[0095] In the complete processing flow at this stage, the user-inputted task text Perform semantic encoding to generate task semantic vectors. This vector fully captures the semantic information and contextual features of the task. Subsequently, the task semantic vector... Through multi-layer nonlinear transformations and residual connections, the network progressively extracts the complexity features of the task, ultimately outputting a complexity vector. These correspond to knowledge density, number of reasoning steps, tool dependence, and interaction complexity, respectively. Based on this complexity vector, a comprehensive complexity score is further calculated. This provides a quantitative indicator of task difficulty for generating agent composition strategies in subsequent stages. The entire process automates the conversion from natural language task description to structured complexity assessment, laying the foundation for dynamic agent composition.

[0096] Step S2: Fuse the task semantic vector and complexity vector to obtain the task representation vector, construct the agent capability relationship graph, and obtain the participation probability of each agent node based on the task representation vector and the agent capability relationship graph to form a dynamic agent combination scheme.

[0097] like Figure 3 As shown, in the graph semantic agent selection and decision-making stage, this embodiment uses graph neural networks to model agent relationships and generate the optimal combination scheme based on task requirements and complexity.

[0098] Step S2.1: Merge the task semantic vector and complexity vector to obtain the task representation vector. The process is as follows:

[0099] The method in this embodiment is based on the task semantic vector obtained during the task complexity analysis and evaluation phase. and complexity vector First, the two are fused to obtain a more comprehensive task representation vector. Specifically, the Task Representation Fusion Module (TRFM) is used. This module is responsible for fusing the task semantic vector and complexity vector to generate a more comprehensive task representation. This module uses, but is not limited to, the lightweight language model Qwen3-0.6B to fuse the task semantic vector... and complexity vector As input, these two vectors are jointly encoded to output a task semantic vector. This provides rich task context for agent selection. By modeling the agent capability relationships using graph neural networks and generating the optimal agent combination strategy, the computation process can be represented as follows:

[0100]

[0101] in, This indicates that the task semantic vector and complexity vector The fusion process generates a task representation vector. This vector contains semantic understanding and complexity feature information of the task.

[0102] Step S2.2: Initialize the capability feature vectors based on the capability descriptions of the agents, determine the relationships between agents based on the similarity of their capability feature vectors, and construct an agent capability relationship graph based on the relationships between agents. The process is as follows:

[0103] This invention constructs an Agent Relation Construction Module (ARCM). This module identifies four types of relationships by calculating the similarity between agent capability representation vectors, and constructs a weighted directed graph, namely the agent capability relationship graph, to provide structured input for subsequent graph neural network processing.

[0104] Constructing a capability relationship graph of intelligent agents The construction process of this graph includes two steps: node construction and edge construction.

[0105] Regarding node construction, if each agent is considered a node, then for each agent node... The agent's capability description text is initialized using a pre-defined method. To ensure consistency in the feature space, the agent's capability description is initially encoded using, but not limited to, a BGE model, to generate the agent. capability feature vector This feature vector describes the agent's domain of expertise, processing power, resource consumption, and response time.

[0106] In terms of edge construction, the relationship edge between intelligent agents Specifically, the relationship edges between agents are determined based on the similarity of capability feature vectors and predefined relationship rules, and the relationship type between agents is determined by calculating the cosine similarity between capability feature vectors.

[0107]

[0108] in, Represents the feature vectors of two capabilities , The similarity between them. When the similarity is higher than the first similarity threshold. Establish collaborative enhancement edges when similarity is at the same level. When the similarity is within a certain range, complementary edges are established. When the similarity is below the third similarity threshold, overlapping edges are established. Establish conflict exclusion edges in a timely manner.

[0109] First similarity threshold Second similarity threshold Third similarity threshold The settings are based on the analysis of a large amount of experimental data: It can be set to 0.8, indicating that there is a significant synergistic effect among agents with highly similar (≥80%) capability vectors; It can be set to 0.6, indicating that agents with a similarity between 60% and 80% have complementary abilities; A similarity threshold of 0.3 indicates that agents with a similarity between 30% and 60% have some overlapping capabilities; agents with a similarity below 30% are considered to have excessively different capabilities, potentially leading to conflict. This hierarchical threshold design effectively captures different relationship types between agents, providing structured relationship information for subsequent graph convolutional networks. The numerical settings of the three similarity thresholds here are just an example; they can be adaptively modified according to actual needs.

[0110] Based on the construction rules for the four edge types mentioned above, the adjacency matrix of the agent relationship graph is generated. ,in, Number of agents. Adjacency matrix. The elements in the adjacency matrix represent the strength of the relationships between agents. The strength of a relationship is the weight corresponding to the type of relationship edge between agents. Different types of relationship edges are assigned different weights. This weighting method allows the adjacency matrix to reflect the importance of different types of relationship edges.

[0111] Based on adjacency matrix The degree matrix is ​​calculated. This is a diagonal matrix, where the diagonal elements represent agent nodes. Weighted degree, degree matrix Used to normalize the adjacency matrix in graph convolution operations, balancing the influence of agent nodes with different connectivity.

[0112] Through the adjacency matrix Sum-degree matrix The structural information of the agent's capability relationship graph is effectively encoded, providing a foundation for subsequent graph convolutional network processing.

[0113] Step S2.3: Construct an initial node feature matrix using the agent and its capability feature vectors. Update the initial node feature matrix using the agent capability relationship graph to obtain the node feature matrix. Then, process the node feature matrix using a multi-condition pooling mechanism to obtain the global graph representation of the agent. The process is as follows:

[0114] An Agent Relation Encoding Module (AREM) was constructed. This network employs an 8-layer graph convolutional structure to capture complex interactions and capability transfer patterns between agents. Through multi-layer graph convolutional operations, AREM enables each agent node to aggregate neighbor node information, generating agent representations that incorporate graph structure information, providing key features for agent selection. AREM consists of an input layer, six hidden layers, and an output layer, each followed by a ReLU activation function and a dropout layer (with a dropout rate of 0.1). This deep graph convolutional design allows the network to perceive multiple neighbor information, effectively modeling indirect collaborative relationships between agents, while the layer-by-layer dimensionality reduction structure helps the network extract more abstract and generalized agent representations, improving the adaptability of combined strategies.

[0115] Based on the aforementioned generated capability feature vectors of the agents, each agent... For the sake of action, together Rows are used to construct the initial node feature matrix, with the dimension of the agent's capability feature vector as the column. ,in, 768 represents the number of agents, and 768 represents the feature dimension for each agent. It's important to understand that 768 here is just an example; other values ​​can be chosen. The Line corresponding intelligent agent capability feature vector .

[0116] Initial node feature matrix As input to the graph convolutional network, and the adjacency matrix Sum-degree matrix Together, these features are used in the subsequent agent relation encoding process. In this way, the semantic capability features of each agent are integrated into the graph structure, providing the initial feature representation of the nodes for the graph convolutional network.

[0117] The GCN update formula is:

[0118]

[0119] in, Indicates the first The node feature matrix of the layer, , For the number of agents, For the first The feature dimension of the layer The adjacency matrix represents the relationship graph of the agents. The degree matrix represents the number of edges connected to it. This is called a symmetric normalized adjacency matrix. This normalization method can balance the influence of agent nodes with different degrees. Indicates the first The learnable weight matrix of the layer, Represents the ReLU activation function. .

[0120] Through multi-layer graph convolution operations, each agent node can aggregate information from its neighboring nodes and update its own feature representation, thereby obtaining a result that incorporates graph structure information. Agent feature representation of all agents in the row This leads to the final node feature matrix. Node feature matrix The The row element is the first Agent feature representation of an agent .

[0121] This invention designs a Multi-Condition Pooling (MCP) mechanism, which summarizes the features of agent nodes through three methods: max pooling, average pooling, and attention pooling, generating a global graph representation of the agent. By dynamically balancing the three pooling information with learnable weights, it captures different aspects of the graph structure and dynamically adjusts the agent selection strategy according to the semantic features and complexity requirements of the current task, providing a global perspective for agent selection decisions. The MCP mechanism includes three pooling operations:

[0122] The node feature matrix is ​​processed using the Max Pooling method. This is used to select the most capable agent and obtain the max-pooled global representation. :

[0123]

[0124] The node feature matrix is ​​processed using the average pooling method. This is used to balance the contributions of different agents, resulting in an average pooled global representation. The calculation formula is:

[0125]

[0126] The node feature matrix is ​​processed using the attention pooling method. Different importance weights are assigned to different agents based on task characteristics, resulting in an attention-pooled global representation. The calculation formula is as follows:

[0127]

[0128]

[0129] in, Represents intelligent agents The characteristics of the intelligent agent are represented. Represents intelligent agents Attention weights Task representation vector.

[0130] The global graph representation of the agent is obtained by weighting the global representations of max pooling, average pooling, and attention pooling. The three pooling results are then fused using weights to obtain the final global graph representation of the agent.

[0131]

[0132] in, , , These are the fusion weights of max pooling, average pooling, and attention pooling, respectively, satisfying... .

[0133] Step S2.4: Calculate the participation probability of each agent node based on the agent feature representation, agent global graph representation, and task representation vector in the node feature matrix. Retain agent nodes that meet the selection threshold to form a dynamic agent combination scheme. The process is as follows:

[0134] This embodiment constructs an Agent Selection Decision Module (ASDM), which comprehensively considers agent feature representations, agent global graph representations, and task representation vectors to calculate the participation probability of each agent. ASDM fuses multi-source information through a learnable weight matrix and dynamically adjusts the selection threshold based on task complexity to achieve adaptive optimization of agent composition.

[0135] In agent selection decision-making, the feature representations of individual agents are comprehensively considered. Global graph representation of intelligent agents and task representation vector Calculate the participation probability of each agent:

[0136]

[0137] in, Represents intelligent agents The probability of participation is [0,1]. The weight matrix represents the feature representation of the agent. This represents the weight matrix of the global representation. This represents the weight matrix of the task representation. For activation function, This is the bias vector.

[0138] when Greater than the preset selection threshold At that time, a single intelligent agent Those selected to participate in task execution form the final intelligent agent composition scheme. Scoring based on task complexity Dynamically adjust the agent's selection threshold:

[0139]

[0140] Among them, when the intelligent agent participation probability When the value exceeds this threshold, the agent... Selected to participate in task execution This represents the baseline selection threshold, serving as the benchmark for agent selection. This represents the complexity adjustment coefficient, a negative value used to control the degree to which the task complexity score affects the selection threshold. When When increasing, due to Negative value This will correspondingly reduce [the number of agents], thereby allowing more agents to participate in task execution to handle more complex task requirements. For example, when [the number of agents]... (For extremely simple tasks) ;when (For extremely complex tasks) That is, the selection threshold is reduced. For complex tasks, it lowers the threshold for agent selection, giving more agents the opportunity to participate in task execution.

[0141] This dynamic threshold mechanism enables the system to adaptively adjust the size of the agent combination based on the task complexity score, allocating more resources to complex tasks and keeping the configuration lean for simple tasks, thereby optimizing resource utilization.

[0142] This invention supports incorporating external tools as special types of intelligent agent nodes into the graph structure. These tool nodes possess specific capability identifiers and invocation interfaces. External tools include web search engines, knowledge base retrieval engines, code executors, mathematical calculators, database query interfaces, etc. The capability feature vectors of tool nodes are generated by encoding their functional description text using a BGE model, employing the same processing method as ordinary intelligent agent nodes. Through a unified graph representation framework, the system can simultaneously consider the combined optimization of internal intelligent agents and external tools, achieving more comprehensive task processing capabilities.

[0143] In the complete processing flow of this stage, the task semantic vector Relationship diagram with intelligent agents The inputs are fed into a graph neural network, where multi-layer graph convolution updates the features of agent nodes. After passing through a multi-condition pooling mechanism and a binary classification output layer, a participation probability is generated for each agent node, forming a dynamic agent combination scheme. This scheme not only considers task semantic vectors and task complexity scores but also fully models the cooperation and conflict relationships between agents, ensuring that the selected agent combination can efficiently collaborate to complete the task.

[0144] Step S3: Decompose the task according to the agent composition scheme, construct the sub-task dependency graph, and schedule the execution order of the sub-tasks through topological sorting to realize the agent's collaborative execution and generate task results. The process is as follows:

[0145] like Figure 4 As shown, in the task decomposition and collaborative execution phase, this embodiment first decomposes the task to construct a sub-task dependency graph, and then determines the execution order of the sub-tasks.

[0146] Step S3.1: Based on the agent composition scheme, the original task is hierarchically decomposed, the dependencies between subtasks are analyzed, and a subtask dependency graph is constructed. The process is as follows:

[0147] The task text is broken down into multiple subtasks to obtain a set of subtasks;

[0148] Each subtask is treated as a subtask node, and the attributes of the subtask node include the subtask description and the estimated complexity score.

[0149] Calculate the dependency probability between subtasks based on the subtask description text. When the dependency probability exceeds the relationship probability threshold, create a directed edge between the corresponding nodes. Filter all created directed edges to construct the initial subtask dependency graph.

[0150] Use depth-first search to traverse the cycles in the initial subtask dependency graph structure and remove the directed edges with the lowest dependency probability in the cycle from the initial subtask dependency graph.

[0151] The process continues until there are no more loops in the initial subtask dependency graph, at which point the subtask dependency graph is obtained.

[0152] A task decomposition and dependency analysis module was constructed. The agent first receives the task text. Combination scheme with intelligent agents Perform task decomposition operations.

[0153] The task decomposition adopts a recursive refinement strategy, dividing the task text... Decomposed into a set of subtasks , This represents the total number of subtasks. The decomposition process is expressed by the following formula:

[0154]

[0155] in, The task decomposition function is based on the task representation vector. The process involves decomposition, integrating task semantics and complexity information.

[0156] The decomposed subtasks are processed through a directed acyclic graph (DAG) - the initial subtask dependency graph. The graph is constructed using the Task Dependency Analysis Module (TDAM) of this invention. The construction process includes the following steps:

[0157] Node creation: For each subtask Create a corresponding subtask node The subtask node attributes include a subtask description and an estimated complexity score.

[0158] Dependency Relationship Identification: A dual analysis approach based on semantics and logic is employed to identify dependencies between subtasks. At the semantic level, a pre-trained language model is used to analyze the subtask description text and calculate the probability of dependencies between tasks.

[0159]

[0160] in, Subtasks It is a subtask The probability of the dependent task, with a value range of [0,1]. ; Indicates the first Sub-tasks It is the first Sub-tasks Subtasks The task representation vector, AND represents subtasks The task representation vector, Subtasks The complexity vector, Subtasks The complexity vector, This represents the learnable weight matrix for dependency identification. express Activation function This represents a vector concatenation operation. At the logical level, the system predefines a set of task types and corresponding dependency rules; for example, "data acquisition" tasks typically precede "data analysis" tasks.

[0161] Edge creation: When the probability of dependency is high Exceeding the relationship probability threshold At that time, a directed edge is created between the corresponding nodes. , indicating task It is a task Dependencies.

[0162] Based on the above principles, an initial subtask dependency graph is constructed. After constructing the initial subtask dependency graph, it is necessary to ensure that the graph structure is a directed acyclic graph (DAG) for subsequent task scheduling. To this end, the system implements a cycle detection algorithm based on depth-first search (DFS) and a cycle detection and elimination strategy based on dependency strength.

[0163] A circular dependency occurs when subtasks have a circular relationship. For example, if subtask 1 depends on subtask 2, subtask 2 depends on subtask 3, and subtask 3 depends on subtask 1, a circular dependency is formed (1→2→3→1). This situation may occur in complex task decomposition, but it will make it impossible to determine the execution order of the subtasks.

[0164] The process of loop detection and elimination strategy is as follows:

[0165] First, a depth-first search is applied to traverse the initial subtask dependency graph structure, and loops are detected by maintaining access status markers (unvisited, being visited, and visited completely). When the algorithm encounters a subtask node in the "being visited" state during the traversal, it indicates that a loop has been found.

[0166] Once a cycle is detected, the algorithm analyzes the dependency probabilities of all directed edges within the cycle, identifies the directed edge with the lowest dependency probability, and removes it from the initial subtask dependency graph. This process continues until no cycles remain in the initial subtask dependency graph, ultimately resulting in a subtask dependency graph.

[0167] After obtaining the subtask dependency graph, the system determines the execution order of the subtasks through topological sorting. Topological sorting is a sorting algorithm for directed acyclic graphs that ensures that each task is executed only after all its predecessor dependent tasks have been completed.

[0168] Through the above steps, this invention constructs a structurally complete subtask dependency graph, namely the task dependency analysis module. This module not only represents the execution order constraints between subtasks but also includes task priority and task complexity, providing a structured task representation for subsequent agent allocation and execution scheduling. The visual representation of the subtask dependency graph enables the system to intuitively display the task decomposition structure, facilitating human-computer interaction and execution monitoring.

[0169] Step S3.2: Based on the subtask dependency graph, the execution order of subtasks is scheduled through topological sorting to achieve collaborative execution of agents and generate task results. The process is as follows:

[0170] Identify all subtask nodes with an in-degree of 0 in the subtask dependency graph and form a priority queue;

[0171] Take the highest priority subtask node from the priority queue, add it to the execution sequence, and reduce the in-degree of all its successor nodes;

[0172] When the in-degree of a successor node decreases to 0, it is added to the priority queue.

[0173] The process continues until the priority queue is empty, at which point all subtask nodes are sorted to obtain the final execution sequence.

[0174] For each subtask, calculate the capability matching score for each agent, and construct a subset of agent combination schemes using agents whose capability matching scores exceed a set matching threshold.

[0175] Based on the subset of agent combination schemes corresponding to each subtask, the subtasks are executed in the order of the final execution sequence to generate the task results.

[0176] The Subtask Scheduling and Execution Module (SSEM) is responsible for scheduling the execution order of subtasks according to the structure of the subtask dependency graph and assigning subtasks to selected agents. The scheduling process uses a topological sorting algorithm to ensure that dependency constraints are satisfied.

[0177] The topological sorting algorithm is as follows:

[0178] Identify all subtask nodes with an in-degree of 0 in the subtask dependency graph (i.e., subtasks without predecessor dependencies) and form them into a priority queue.

[0179] Take the highest priority subtask node from the priority queue, add it to the execution sequence, and reduce the in-degree of all its successor nodes.

[0180] When the in-degree of a successor node decreases to 0 (indicating that all its predecessor dependencies have been processed), it is added to the priority queue.

[0181] Repeat this process until the priority queue is empty, completing the sorting of all subtask nodes and obtaining the final execution sequence.

[0182] By using topological sorting, the system establishes an execution sequence that satisfies dependency constraints, ensuring the logical correctness of task execution. Based on this, the system assigns priority to each task according to its complexity, prioritizing the execution of more complex tasks while maintaining dependencies.

[0183] The priority calculation formula is as follows:

[0184]

[0185] in, Indicates the first The estimated complexity score of each subtask is used. Subtasks with higher estimated complexity scores receive higher priority and are scheduled first, provided that dependencies are satisfied.

[0186] For each subtask, a capability matching score is calculated for each agent. Agents with capability matching scores exceeding a set matching threshold are used to construct a subset of agent composition schemes. Subtask allocation employs a capability matching score-based allocation strategy, selecting agents from the agent composition schemes. Each subtask Assign the most suitable subset of agent composition schemes The formula for calculating the matching degree is:

[0187]

[0188] in, Subtasks The representation vector, Represents intelligent agents The characteristics of the intelligent agent are represented. This represents the cosine similarity function. Based on the matching score, the system assigns one or more agents to each subtask to ensure the professionalism and efficiency of task execution.

[0189] Example 2

[0190] This embodiment provides a task complexity-driven graph semantic multi-agent collaborative decision-making system, including:

[0191] The task complexity evaluation module is used to obtain the task text, perform semantic encoding to obtain the task semantic vector, evaluate based on the task semantic vector to obtain the complexity vector, and calculate the task complexity score of the complexity vector.

[0192] The agent selection decision module is used to fuse the task semantic vector and complexity vector to obtain the task representation vector, construct the agent capability relationship graph, obtain the participation probability of each agent node based on the task representation vector and the agent capability relationship graph, and form a dynamic agent combination scheme.

[0193] The execution and feedback optimization module is used to decompose tasks according to the agent combination scheme, construct a sub-task dependency graph, schedule the execution order of sub-tasks through topological sorting, realize the agent collaborative execution and generate task results.

[0194] The examples and application scenarios implemented by the above modules and corresponding steps are the same, but are not limited to the content disclosed in Embodiment 1 above. It should be noted that the above modules, as part of the system, can be executed in a computer system such as a set of computer-executable instructions.

[0195] The descriptions of each embodiment in the above embodiments have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0196] The proposed system can be implemented in other ways. For example, the system embodiments described above are merely illustrative, and the division of modules described above is only a logical functional division. In actual implementation, there may be other division methods. For example, multiple modules may be combined or integrated into another system, or some features may be ignored or not executed.

[0197] Example 3

[0198] This embodiment provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method as described in Embodiment 1 above.

[0199] Example 4

[0200] This embodiment provides a computer device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it implements the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method as described in Embodiment 1 above.

[0201] Example 5

[0202] This embodiment provides a computer program product or computer program, including computer instructions stored in a computer-readable storage medium. The processor of a computer device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the computer device to perform the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method described in Embodiment 1 above.

[0203] Those skilled in the art will understand that embodiments of the present invention can provide methods, systems, or computer program products. Therefore, the present invention can take the form of hardware embodiments, software embodiments, or embodiments combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage and optical storage) containing computer-usable program code.

[0204] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, as well as combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0205] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0206] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0207] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0208] While the specific embodiments of the present invention have been described above in conjunction with the accompanying drawings, this is not intended to limit the scope of protection of the present invention. Those skilled in the art should understand that various modifications or variations that can be made by those skilled in the art without creative effort based on the technical solutions of the present invention are still within the scope of protection of the present invention.

Claims

1. A task complexity-driven graph semantic multi-agent cooperative decision-making method, characterized in that, include: Obtain the task text, perform semantic encoding to obtain a task semantic vector, evaluate based on the task semantic vector to obtain a complexity vector, and calculate the task complexity score of the complexity vector, including: Obtain the task text and perform semantic encoding to obtain the task semantic vector; Based on the task semantic vector, a complexity vector is obtained by predicting and evaluating from four dimensions: knowledge density, number of reasoning steps, tool dependence, and interaction complexity. The task complexity score is obtained by weighting and summing the evaluation results of the four dimensions in the complexity vector. The task semantic vector and complexity vector are fused to obtain the task representation vector. An agent capability relationship graph is constructed, and the participation probability of each agent node is obtained based on the task representation vector and the agent capability relationship graph, forming a dynamic agent composition scheme, including: An initial node feature matrix is ​​constructed using the agent and its capability feature vectors. The node feature matrix is ​​then updated using the agent capability relationship graph. The node feature matrix is ​​processed using a multi-condition pooling mechanism to obtain a global graph representation of the agent; The participation probability of each agent node is calculated based on the agent feature representation, agent global graph representation, and task representation vector in the node feature matrix. Retain agent nodes that meet the selection threshold to form a dynamic agent combination scheme; Tasks are decomposed according to the agent composition scheme, a subtask dependency graph is constructed, and the execution order of subtasks is scheduled by topological sorting to achieve collaborative execution of agents and generate task results.

2. The task complexity-driven graph semantic multi-agent cooperative decision-making method as described in claim 1, characterized in that, The process of fusing the task semantic vector and complexity vector to obtain the task representation vector and constructing the agent capability relationship graph includes: The task semantic vector and complexity vector are fused to obtain the task representation vector; Capability feature vectors are obtained by initializing based on the capability descriptions of the agents. The relationships between agents are determined based on the similarity of their capability feature vectors. Finally, an agent capability relationship graph is constructed based on the relationships between agents.

3. The task complexity-driven graph semantic multi-agent cooperative decision-making method as described in claim 1, characterized in that, Based on the agent composition scheme, the task is decomposed and a sub-task dependency graph is constructed, including: The task text is broken down into multiple subtasks to obtain a set of subtasks; Each subtask is treated as a subtask node, and the attributes of the subtask node include the subtask description and the estimated complexity score. Calculate the dependency probability between subtasks based on the subtask description text. When the dependency probability exceeds the relationship probability threshold, create a directed edge between the corresponding nodes. Filter all created directed edges to construct the initial subtask dependency graph. Use depth-first search to traverse the cycles in the initial subtask dependency graph structure and remove the directed edges with the lowest dependency probability in the cycle from the initial subtask dependency graph. The process continues until there are no more loops in the initial subtask dependency graph, at which point the subtask dependency graph is obtained.

4. The task complexity-driven graph semantic multi-agent cooperative decision-making method as described in claim 1, characterized in that, The method of scheduling the execution order of subtasks through topological sorting to achieve collaborative execution of agents and generate task results includes: Identify all subtask nodes with an in-degree of 0 in the subtask dependency graph and form a priority queue; Take the highest priority subtask node from the priority queue, add it to the execution sequence, and reduce the in-degree of all its successor nodes; When the in-degree of a successor node decreases to 0, it is added to the priority queue. The process continues until the priority queue is empty, at which point all subtask nodes are sorted to obtain the final execution sequence. For each subtask, calculate the capability matching score for each agent, and construct a subset of agent combination schemes using agents whose capability matching scores exceed a set matching threshold. Based on the subset of agent combination schemes corresponding to each subtask, the subtasks are executed in the order of the final execution sequence to generate the task results.

5. A task complexity-driven graph semantic multi-agent collaborative decision-making system, characterized in that, include: The task complexity evaluation module is used to acquire the task text, perform semantic encoding to obtain a task semantic vector, evaluate based on the task semantic vector to obtain a complexity vector, and calculate the task complexity score of the complexity vector, including: Obtain the task text and perform semantic encoding to obtain the task semantic vector; Based on the task semantic vector, a complexity vector is obtained by predicting and evaluating from four dimensions: knowledge density, number of reasoning steps, tool dependence, and interaction complexity. The task complexity score is obtained by weighting and summing the evaluation results of the four dimensions in the complexity vector. The agent selection and decision-making module is used to fuse the task semantic vector and complexity vector to obtain the task representation vector, construct an agent capability relationship graph, obtain the participation probability of each agent node based on the task representation vector and the agent capability relationship graph, and form a dynamic agent combination scheme, including: An initial node feature matrix is ​​constructed using the agent and its capability feature vectors. The node feature matrix is ​​then updated using the agent capability relationship graph. The node feature matrix is ​​processed using a multi-condition pooling mechanism to obtain a global graph representation of the agent; The participation probability of each agent node is calculated based on the agent feature representation, agent global graph representation, and task representation vector in the node feature matrix. Retain agent nodes that meet the selection threshold to form a dynamic agent combination scheme; The execution and feedback optimization module is used to decompose tasks according to the agent combination scheme, build sub-task dependencies, schedule the execution order through topological sorting, realize the agent collaborative execution and generate task results.

6. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method as described in any one of claims 1-4.

7. A computer device, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the steps in the task complexity-driven graph semantic multi-agent cooperative decision-making method as described in any one of claims 1-4.

8. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the steps in the task complexity-driven graph semantic multi-agent collaborative decision-making method as described in any one of claims 1-4.

Images