Large model agent collaborative scheduling method and system oriented to complex tasks

Abstract

The invention provides a large model agent collaborative scheduling method and system oriented to complex tasks, relates to the technical field of artificial intelligence, and comprises the steps of task decomposition, feature extraction, agent matching, dynamic scoring, scheduling scheme generation and optimization, execution monitoring, exception handling and the like to realize efficient collaboration of large model agents. According to the method, accurate matching can be carried out according to task characteristics and intelligent agent capabilities, the task completion efficiency and quality are improved, meanwhile, the dynamic adjustment capability is achieved, abnormal conditions in the execution process are effectively handled, and the system robustness is enhanced.

Description

Technical Field

[0001] The present invention relates to the field of artificial intelligence technology, and in particular to a method and system for collaborative scheduling of large-model intelligent agents for complex tasks. Background Art

[0002] With the rapid development of artificial intelligence (AI), large language models (LLMs), as foundational AI models, have demonstrated powerful capabilities, capable of handling a wide range of complex tasks. These large-scale intelligent agents, leveraging their advanced natural language processing, knowledge reasoning, and multimodal understanding capabilities, are playing an increasingly important role in information retrieval, content creation, and decision support. For complex tasks, a single agent often struggles to efficiently complete all steps, requiring the collaborative efforts of multiple specialized agents to form a "large-scale agent swarm" to jointly tackle the task. Various scheduling frameworks have emerged in the field of agent collaboration, aiming to efficiently organize multiple agents to work together to solve complex problems.

[0003] However, existing collaborative scheduling methods for large-scale intelligent agents have obvious shortcomings. First, existing methods often oversimplify the decomposition of complex tasks and lack in-depth analysis of the complex dependencies between tasks, resulting in inaccurate task decomposition and the inability to fully utilize the professional advantages of each intelligent agent. Secondly, the intelligent agent selection mechanism is mostly based on static capability matching, failing to consider the dynamic performance differences of intelligent agents in different task environments and the synergy between intelligent agents, resulting in the selected intelligent agent combination being inefficient in actual execution. Finally, existing scheduling systems generally lack effective exception handling mechanisms. When deviations or failures occur during the execution of intelligent agents, there is a lack of real-time monitoring and dynamic adjustment capabilities, which cannot guarantee the stable completion of tasks. In particular, when faced with highly complex tasks, the system lacks robustness.

[0004] These problems severely limit the efficiency and reliability of large-model intelligent agents in processing complex tasks. There is an urgent need for a collaborative scheduling method that can accurately decompose tasks, intelligently match intelligent agents, and have dynamic adjustment capabilities to improve the overall performance of the intelligent agent group in complex task processing. Summary of the Invention

[0005] The embodiments of the present invention provide a large-model intelligent agent collaborative scheduling method and system for complex tasks, which can solve the problems in the existing technology.

[0006] A first aspect of an embodiment of the present invention provides a large-model agent collaborative scheduling method for complex tasks, comprising:

[0007] Receive a complex task input by the user, and based on semantic analysis and task dependency analysis, decompose the complex task into multiple subtasks with a certain execution order to obtain a subtask execution sequence; use a pre-trained feature extraction model to extract feature vectors for each subtask in the subtask execution sequence from three dimensions: task goal, execution constraint, and resource requirement, and generate corresponding task feature vectors;

[0008] The task feature vector is input into the agent matching network, which calculates the similarity between the task feature vector and the capability feature vector of each agent in the pre-built large model agent pool, and selects a set of candidate agents that meet the execution capability requirements for each subtask;

[0009] For each agent in the candidate agent set, a deep reinforcement learning network is used to calculate scores for three indicators: timeliness of task completion, accuracy of results, and efficiency of resource utilization, based on its historical task execution records. These three scores are input into a pre-trained agent evaluation model, which comprehensively considers the agent's historical collaborative performance and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses.

[0010] Based on the dynamic comprehensive score, a greedy algorithm is used to select the agent with the highest score for each subtask in the subtask execution sequence, while taking into account the task parallel processing capability of the agent to generate an initial agent scheduling plan;

[0011] The agents selected in the initial agent scheduling scheme and the data interaction relationships between them are mapped into a collaborative graph, where nodes in the graph represent agents, edges represent data transmission between agents, and edge weights represent data transmission overhead. The collaborative graph is analyzed using a graph neural network to predict the collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the selection of agents and the data transmission path are optimized using a graph structure optimization algorithm until the predicted efficiency meets the requirements, thereby obtaining a final scheduling scheme.

[0012] According to the agent selection results and data interaction paths in the final scheduling plan, the corresponding agents are started and data transmission channels are established. The agents begin to collaboratively execute tasks according to the subtask execution sequence, and the execution status and collaborative effects of the agents are monitored in real time. When execution anomalies or collaborative anomalies of the agents are detected, the abnormal information is fed back to the agent evaluation model to update the dynamic comprehensive score, and the emergency scheduling mechanism is triggered to re-select agents and regenerate collaborative plans.

[0013] The task feature vector is input into the agent matching network. The network calculates the similarity between the task feature vector and the capability feature vector of each agent in the pre-built large model agent pool. The candidate agent set that meets the execution capability requirements for each subtask is selected, including:

[0014] Obtain an input task feature vector, the task feature vector including task objective features, execution constraint features, and resource requirement features; read agent pool information from a preset agent database, the information of each agent in the agent pool including agent identification, function description, call interface, hardware requirements, and capability feature vector; calculate the similarity value between the task feature vector and the capability feature vector of each agent in the agent pool based on the cosine similarity algorithm to generate a task-agent similarity matrix;

[0015] According to the task-agent similarity matrix, a similarity threshold is set, and the optimal similarity threshold is determined through an adaptive threshold screening algorithm. Agents with similarity values ​​greater than the optimal similarity threshold are screened as candidate agents. At the same time, a matching degree is calculated based on the hardware requirements of the agents and the hardware resources of the current system, and agents whose hardware resources do not meet the requirements are eliminated;

[0016] For the selected candidate agents, obtain their historical call records, which include call time, execution status, resource usage, and execution results;

[0017] Analyzing the historical call records using a time series neural network to predict the reliability index of each candidate agent when performing the current task, the reliability index includes execution success rate, average response time, and resource utilization efficiency; ranking the candidate agents based on the reliability index, and selecting the top N agents to form a candidate agent set;

[0018] Generate call configuration information for the candidate agent set, which includes agent identification, call interface parameters, resource quota and data interaction format; submit the candidate agent set and its call configuration information to the task scheduling module for subsequent agent collaborative scheduling.

[0019] For each agent in the candidate agent set, based on its historical task execution records, a deep reinforcement learning network is used to calculate the scores of three indicators: task completion timeliness, result accuracy, and resource utilization efficiency. These three scores are input into the pre-trained agent evaluation model. The model comprehensively considers the historical collaborative performance of the agent and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses. It includes:

[0020] Receive candidate agent set information and obtain historical task execution records for each candidate agent, wherein the historical task execution records include task start time, completion time, execution results, resource consumption data, and collaborative interaction data; extract task execution timing features from the historical task execution records, including task execution duration, task response delay, execution result accuracy, computing resource occupancy rate, and storage resource utilization rate;

[0021] Inputting the task execution timing features into a deep reinforcement learning network, the network uses a temporal difference learning method to calculate a task timeliness score based on the deviation between the task completion time and the expected completion time, calculates an accuracy score based on the consistency between the execution result and the standard result, and calculates a resource utilization efficiency score based on the comparison of resource occupancy rate with the benchmark value;

[0022] Extracting agent collaboration data from the historical task execution records, including the frequency of data interaction with other agents, the amount of data transmitted, and the quality of collaborative task completion; analyzing the collaborative behavior patterns of the agents using a graph attention network, and calculating the adaptability score of the agents in the collaborative scenario. The adaptability score is based on a comprehensive assessment of the collaborative task completion efficiency, data interaction efficiency, and collaborative fault tolerance.

[0023] Input the task timeliness score, accuracy score, resource utilization efficiency score and adaptability score into the evaluation fusion network, which adopts a dynamic weight adaptive mechanism to dynamically adjust the weight coefficient of each score according to the current task characteristics and output a dynamic comprehensive score of the agent;

[0024] Receive the task execution status data of the intelligent agent in real time, update the timing characteristics and collaboration data when a new execution record is generated, recalculate the scores, and adjust the dynamic comprehensive score in real time.

[0025] Based on the dynamic comprehensive score, a greedy algorithm is used to select the agent with the highest score for each subtask in the subtask execution sequence. At the same time, the task parallel processing capability of the agent is taken into consideration to generate an initial agent scheduling scheme including:

[0026] Receive a subtask execution sequence and a dynamic comprehensive score of a candidate agent, wherein the subtask execution sequence includes the execution order of multiple subtasks to be executed and the dependencies between tasks; obtain task parallel processing capability information of the candidate agent, wherein the task parallel processing capability information includes the maximum number of parallel tasks, task switching overhead, and resource isolation level;

[0027] A task execution directed acyclic graph is constructed based on task dependencies, where nodes represent subtasks and edges represent dependencies and data flows between tasks. A topological sorting algorithm is used to determine task groups that can be executed in parallel. Each task group in the task execution directed acyclic graph is traversed, and the following operations are performed on the subtasks in each task group: candidate agents are traversed in descending order of dynamic comprehensive scores. The current task load of the candidate agent is checked to see if it is less than its maximum number of parallel tasks. The candidate agent is verified to see if it meets the resource isolation requirements of the subtask. When a candidate agent that meets the conditions is found, the task switching overhead and resource scheduling overhead of the agent in executing the current subtask are calculated. Combined with the dynamic comprehensive score, a multi-objective greedy strategy is used to determine the optimal agent, and the selected agent is assigned to the current subtask.

[0028] For the subtasks to which the intelligent agent has been assigned, scheduling configuration information is generated, and the scheduling configuration information includes the intelligent agent startup parameters, resource quota, data exchange interface and task switching strategy; the intelligent agent allocation results and scheduling configuration information of all subtasks are summarized to form an initial intelligent agent scheduling plan, and the initial intelligent agent scheduling plan includes a task-agent mapping relationship table, a resource allocation plan and a scheduling timing table.

[0029] The agents selected in the initial agent scheduling scheme and the data interaction relationships between them are mapped into a collaborative graph. The nodes in the graph represent agents, the edges represent data transmission between agents, and the weights of the edges represent the data transmission overhead. The collaborative graph is analyzed through a graph neural network to predict the collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the graph structure optimization algorithm is used to optimize the agent selection and data transmission path until the predicted efficiency meets the requirements. The final scheduling scheme includes:

[0030] Receive the initial agent scheduling plan, extract the agent selection results and task allocation information from it, and determine the data interaction relationship between agents based on the task allocation information; use the selected agents as nodes and the data interaction relationships as connecting edges to generate an initial collaborative graph, and at the same time extract the historical data transmission records between agents from the system operation log;

[0031] Based on the historical data transmission records, the latency characteristics, bandwidth occupancy characteristics, and transmission reliability characteristics of each data transmission edge are calculated, and these characteristic values ​​are added to the collaborative graph as edge weight attributes;

[0032] The graph attention mechanism is used to analyze the connectivity distribution of nodes, the clustering coefficient of edges, and the path complexity in the collaborative graph. These graph structural features are input into a pre-trained efficiency prediction network, which outputs a collaborative execution efficiency prediction value. The efficiency prediction value represents the overall performance of the collaborative execution of tasks by the agents under the current scheduling scheme.

[0033] Compare the predicted efficiency value with the system's preset efficiency target threshold. When the predicted value is lower than the threshold, locate the efficiency bottleneck based on the graph attention analysis results, and find the data transmission hotspot areas and paths with high transmission overhead;

[0034] For identified efficiency bottlenecks, agents with better performance are selected from the candidate agent pool to replace bottleneck nodes. At the same time, data transmission paths are adjusted to reduce cross-node data transmission through the principle of proximity allocation. A data caching mechanism is established between nodes with frequent data interaction to achieve local storage and fast access to data.

[0035] The collaborative graph is regenerated using the updated agent selection scheme and data transmission strategy, and the efficiency prediction network is reused to calculate a new efficiency prediction value. When the prediction value continues to be lower than the threshold, the optimization steps are repeated until the efficiency prediction value meets the requirements.

[0036] Output the final optimized scheduling plan, which includes the optimized agent selection results, data transmission routing strategy and collaborative scheduling mechanism, and send these configuration information to the task execution engine for deployment.

[0037] According to the agent selection results and data interaction paths in the final scheduling plan, the corresponding agents are started and data transmission channels are established. The agents begin to collaboratively execute tasks according to the subtask execution sequence, and the execution status and collaborative effects of the agents are monitored in real time. When an execution anomaly or collaborative anomaly is detected in the agent, the anomaly information is fed back to the agent evaluation model to update the dynamic comprehensive score, and the emergency scheduling mechanism is triggered to re-select the agent and generate a collaborative plan, including:

[0038] Receive the final scheduling plan, extract the agent selection results and task allocation information, send the agent startup instruction to the target computing node, and configure the data transmission channel between agents according to the data interaction path, and allocate corresponding computing resources, network bandwidth and cache space to each channel;

[0039] Deploy a status monitoring probe in the running environment of each agent, which continuously collects the agent's computing load data, memory usage data, response latency data, data throughput data, and collaborative message data;

[0040] The collected status data is transmitted to the monitoring center in real time. The monitoring center calculates the normal value range of each indicator based on historical operation data and detects indicator anomalies through a sliding time window. When a certain indicator exceeds the normal range, the complete status data at the time of the anomaly is extracted to generate an anomaly feature vector.

[0041] According to the subtask execution sequence, the agent is triggered to execute tasks in sequence. The agent obtains input data through the pre-established data transmission channel, and after processing, transmits the output data to the downstream agent through the specified channel;

[0042] Analyze the abnormal feature vector in real time, match the feature vector with the abnormal pattern in the historical anomaly database for similarity, determine the abnormal level according to the matching result, and determine the abnormal impact range based on the abnormal propagation path analysis. Adopt differentiated processing strategies for different abnormal levels: dynamically adjust the resource quota and operating parameters of the abnormal agent in case of minor anomalies; reduce the dynamic score of the abnormal agent and shrink its task allocation scope in case of moderate anomalies; activate alternative agents to complete task migration and take over in case of severe anomalies.

[0043] A second aspect of an embodiment of the present invention provides a large-model intelligent agent collaborative scheduling system for complex tasks, including:

[0044] The first unit is configured to receive a complex task input by a user and, based on semantic analysis and task dependency analysis, decompose the complex task into multiple subtasks with a sequential execution order to obtain a subtask execution sequence; and utilize a pre-trained feature extraction model to extract feature vectors from each subtask in the subtask execution sequence based on three dimensions: task objectives, execution constraints, and resource requirements, to generate corresponding task feature vectors.

[0045] The second unit is used to input the task feature vector into the agent matching network. The network calculates the similarity between the task feature vector and the ability feature vector of each agent in the pre-built large model agent pool, and selects a set of candidate agents that meet the execution ability requirements for each subtask;

[0046] A third unit is configured to calculate, for each agent in the candidate agent set, a score for three indicators: timeliness of task completion, accuracy of results, and efficiency of resource utilization, based on its historical task execution records, using a deep reinforcement learning network. These three scores are input into a pre-trained agent evaluation model. The model comprehensively considers the historical collaborative performance of the agent and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses.

[0047] A fourth unit is configured to select the agent with the highest score for each subtask in the subtask execution sequence based on the dynamic comprehensive score using a greedy algorithm, while taking into account the task parallel processing capability of the agent, to generate an initial agent scheduling plan;

[0048] The fifth unit is configured to map the agents selected in the initial agent scheduling plan and the data interaction relationships between them into a collaborative graph, where nodes in the graph represent agents, edges represent data transmission between agents, and edge weights represent data transmission overhead. The collaborative graph is analyzed using a graph neural network to predict collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the selection of agents and data transmission paths are optimized using a graph structure optimization algorithm until the predicted efficiency meets the requirements, thereby obtaining a final scheduling plan.

[0049] The sixth unit is used to start the corresponding agent and establish a data transmission channel according to the agent selection results and data interaction path in the final scheduling plan. The agent begins to collaboratively execute tasks according to the subtask execution sequence, monitors the execution status and collaborative effect of the agent in real time, and when it is detected that the agent has an execution anomaly or a collaborative anomaly, the anomaly information is fed back to the agent evaluation model to update the dynamic comprehensive score, and trigger the emergency scheduling mechanism to re-select the agent and regenerate the collaborative plan.

[0050] According to a third aspect of the embodiments of the present invention,

[0051] An electronic device is provided, comprising:

[0052] processor;

[0053] a memory for storing processor-executable instructions;

[0054] The processor is configured to call the instructions stored in the memory to execute the aforementioned method.

[0055] According to a fourth aspect of the embodiments of the present invention,

[0056] A computer-readable storage medium is provided, on which computer program instructions are stored. When the computer program instructions are executed by a processor, the method described above is implemented.

[0057] The beneficial effects of this application are as follows:

[0058] The large-model intelligent agent collaborative scheduling method for complex tasks provided by the present invention accurately identifies the key characteristics of subtasks through task decomposition and feature extraction, achieves efficient matching of tasks and intelligent agents, and significantly improves the execution accuracy and completion quality of complex tasks.

[0059] This method adopts a multi-dimensional evaluation and dynamic scoring mechanism, combined with deep reinforcement learning technology to conduct real-time evaluation of the execution ability of the intelligent agent, and optimizes the collaborative structure through graph neural network, which greatly reduces the communication overhead between intelligent agents and improves the overall collaborative efficiency and resource utilization of the system.

[0060] The present invention also has real-time monitoring and emergency dispatch functions, can quickly identify and respond to abnormal situations during the execution process, automatically trigger the reselection of intelligent agents and optimization of collaborative solutions, ensuring the stability and robustness of complex tasks in various environments, and is suitable for changeable and complex intelligent agent collaboration scenarios. BRIEF DESCRIPTION OF THE DRAWINGS

[0061] Figure 1 This is a flow chart of a method for collaborative scheduling of large-model intelligent agents for complex tasks according to an embodiment of the present invention. DETAILED DESCRIPTION

[0062] To make the objectives, technical solutions, and advantages of the embodiments of the present invention more clear, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts shall fall within the scope of protection of the present invention.

[0063] The following specific embodiments are used to describe the technical solution of the present invention in detail. The following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described in detail in some embodiments.

[0064] Figure 1 This is a flow chart of a large-scale intelligent agent collaborative scheduling method for complex tasks according to an embodiment of the present invention. Figure 1 As shown, the method includes:

[0065] Receive a complex task input by the user, and based on semantic analysis and task dependency analysis, decompose the complex task into multiple subtasks with a certain execution order to obtain a subtask execution sequence; use a pre-trained feature extraction model to extract feature vectors for each subtask in the subtask execution sequence from three dimensions: task goal, execution constraint, and resource requirement, and generate corresponding task feature vectors;

[0066] The task feature vector is input into the agent matching network, which calculates the similarity between the task feature vector and the capability feature vector of each agent in the pre-built large model agent pool, and selects a set of candidate agents that meet the execution capability requirements for each subtask;

[0067] For each agent in the candidate agent set, a deep reinforcement learning network is used to calculate scores for three indicators: timeliness of task completion, accuracy of results, and efficiency of resource utilization, based on its historical task execution records. These three scores are input into a pre-trained agent evaluation model, which comprehensively considers the agent's historical collaborative performance and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses.

[0068] Based on the dynamic comprehensive score, a greedy algorithm is used to select the agent with the highest score for each subtask in the subtask execution sequence, while taking into account the task parallel processing capability of the agent to generate an initial agent scheduling plan;

[0069] The agents selected in the initial agent scheduling scheme and the data interaction relationships between them are mapped into a collaborative graph, where nodes in the graph represent agents, edges represent data transmission between agents, and edge weights represent data transmission overhead. The collaborative graph is analyzed using a graph neural network to predict the collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the selection of agents and the data transmission path are optimized using a graph structure optimization algorithm until the predicted efficiency meets the requirements, thereby obtaining a final scheduling scheme.

[0070] According to the agent selection results and data interaction paths in the final scheduling plan, the corresponding agents are started and data transmission channels are established. The agents begin to collaboratively execute tasks according to the subtask execution sequence, and the execution status and collaborative effects of the agents are monitored in real time. When execution anomalies or collaborative anomalies of the agents are detected, the abnormal information is fed back to the agent evaluation model to update the dynamic comprehensive score, and the emergency scheduling mechanism is triggered to re-select agents and regenerate collaborative plans.

[0071] In an optional embodiment, the task feature vector is input into an agent matching network. The network performs similarity calculation based on the task feature vector and the capability feature vectors of each agent in a pre-built large model agent pool. The set of candidate agents that meet the execution capability requirements for each subtask is selected, including:

[0072] Obtain an input task feature vector, the task feature vector including task objective features, execution constraint features, and resource requirement features; read agent pool information from a preset agent database, the information of each agent in the agent pool including agent identification, function description, call interface, hardware requirements, and capability feature vector; calculate the similarity value between the task feature vector and the capability feature vector of each agent in the agent pool based on the cosine similarity algorithm to generate a task-agent similarity matrix;

[0073] According to the task-agent similarity matrix, a similarity threshold is set, and the optimal similarity threshold is determined through an adaptive threshold screening algorithm. Agents with similarity values ​​greater than the optimal similarity threshold are screened as candidate agents. At the same time, a matching degree is calculated based on the hardware requirements of the agents and the hardware resources of the current system, and agents whose hardware resources do not meet the requirements are eliminated;

[0074] For the selected candidate agents, obtain their historical call records, which include call time, execution status, resource usage, and execution results;

[0075] Analyzing the historical call records using a time series neural network to predict the reliability index of each candidate agent when performing the current task, the reliability index includes execution success rate, average response time, and resource utilization efficiency; ranking the candidate agents based on the reliability index, and selecting the top N agents to form a candidate agent set;

[0076] Generate call configuration information for the candidate agent set, which includes agent identification, call interface parameters, resource quota and data interaction format; submit the candidate agent set and its call configuration information to the task scheduling module for subsequent agent collaborative scheduling.

[0077] This embodiment provides a method for inputting a task feature vector into an agent matching network to screen a set of candidate agents. The method is implemented in a computer system comprising a processor, a memory, and a network interface. The processor executes instructions stored in the memory to implement the following steps.

[0078] The system receives as input a task feature vector, which consists of three components: a task objective feature, an execution constraint feature, and a resource requirement feature. The task objective feature describes the specific goal and expected output of the task, for example, "Generate a 1500-word article on the ethics of artificial intelligence." The execution constraint feature includes constraints such as the task completion time limit and execution accuracy, for example, "The task must be completed within 3 hours with an accuracy greater than 95%." The resource requirement feature specifies the computing and storage resources required for task execution, for example, "8GB of memory and a 4-core CPU are required." Each feature is represented as a numerical vector. For example, the task objective feature can be represented as [0.85, 0.62, 0.73, 0.91], the execution constraint feature as [0.75, 0.88, 0.92], and the resource requirement feature as [0.65, 0.78, 0.82]. These feature vectors are generated from the task description text using a feature extraction algorithm.

[0079] The system reads agent pool information from a pre-set agent database. This database stores detailed information about multiple agents, including agent identifiers (e.g., "Agent-001"), functional descriptions ("excels in text generation and summarization"), call interfaces ("RESTful API: https: / / api.agent.com / text / generate"), hardware requirements ("at least 4GB of memory, 2 CPU cores"), and capability feature vectors ([0.92, 0.87, 0.65, 0.78]). The capability feature vectors describe the agent's performance across different capability dimensions, such as language comprehension, logical reasoning, and creative thinking.

[0080] The system calculates the similarity between the task feature vector and each agent's capability feature vector based on the cosine similarity algorithm. Specifically, the system aligns the task feature vector and the agent's capability feature vector in the same dimensional space, then calculates the dot product of the two vectors divided by the product of their moduli to obtain the similarity value. For example, the similarity between the task feature vector [0.75, 0.82, 0.69, 0.91] and agent A's capability feature vector [0.81, 0.77, 0.72, 0.88] is calculated to be 0.87, and the similarity between the task feature vector [0.65, 0.59, 0.88, 0.72] and agent B's capability feature vector [0.65, 0.59, 0.88, 0.72] is calculated to be 0.65. After calculating the similarity for all agents, the system generates a task-agent similarity matrix, in which each element represents the similarity value between a specific task and a specific agent.

[0081] The system determines the optimal similarity threshold through an adaptive threshold screening algorithm. The algorithm first sets the initial threshold to 0.6, and then dynamically adjusts the threshold based on the complexity, urgency, and number of available agents of the current task. If the task complexity is high and the urgency is low, the system may increase the threshold to 0.75 to screen more professional agents; if the number of available agents is small, the system may lower the threshold to 0.55 to ensure that there are enough candidate agents. After determining the optimal threshold, the system screens out agents with similarity values ​​greater than the threshold. At the same time, the system obtains the current hardware resource status (such as 12GB of available memory and 8 available CPU cores) and performs a matching calculation with the hardware requirements of each candidate agent. If the agent requires 8GB of memory but only 4GB is currently available, the matching degree is 0.5; the system sets the hardware matching threshold to 0.8, and agents below this value will be eliminated.

[0082] For each candidate agent, the system retrieves its historical call records from the agent run log database. Each record includes the call time ("2023-06-15 14:30:25"), execution status ("Success" / "Failure" / "Partially Completed"), resource usage ("CPU: 75%, Memory: 3.2GB"), and execution result ("Output text length 1200 words, quality score 4.5 / 5"). The system collects the most recent 30 call records for each agent, forming time series data.

[0083] The system uses a time-series neural network to analyze historical call records and predict the reliability metrics of candidate agents. A neural network model with an LSTM (long short-term memory) layer is constructed. The input is the sequence of historical agent call records, and the output is the predicted values ​​of three reliability metrics: execution success rate, average response time, and resource efficiency. For example, the predicted metrics for agent A are [success rate: 0.92, response time: 18 seconds, resource efficiency: 0.85], and the predicted metrics for agent B are [success rate: 0.87, response time: 25 seconds, resource efficiency: 0.79]. The system calculates the comprehensive score through a weighted summation with weights of [0.5, 0.3, 0.2], resulting in a comprehensive score of 0.865 for agent A and 0.824 for agent B. The system ranks the candidate agents based on the comprehensive scores and selects the top N (for example, N = 3) agents to form the candidate agent set.

[0084] The system generates call configuration information for the candidate agent set. For each selected agent, the system generates configuration information including the agent identifier ("Agent-005"), call interface parameters ("max_tokens = 1500, feature = 0.8"), resource quota ("memory limit: 6GB, CPU time slice: 60%), and data exchange format ("input format: JSON, output format: Markdown"). This configuration information is dynamically generated based on the task characteristics and agent features to ensure the agent can efficiently execute the task.

[0085] The system submits the candidate agent set and its call configuration information to the task scheduling module, which is responsible for the subsequent agent collaborative scheduling, task distribution and result aggregation, thereby completing the entire large-model agent matching and scheduling process.

[0086] In an optional embodiment, for each agent in the candidate agent set, a score for three indicators, namely, task completion timeliness, result accuracy, and resource utilization efficiency, is calculated using a deep reinforcement learning network based on its historical task execution records. These three scores are input into a pre-trained agent evaluation model. The model comprehensively considers the agent's historical collaborative performance and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses, including:

[0087] Receive candidate agent set information and obtain historical task execution records for each candidate agent, wherein the historical task execution records include task start time, completion time, execution results, resource consumption data, and collaborative interaction data; extract task execution timing features from the historical task execution records, including task execution duration, task response delay, execution result accuracy, computing resource occupancy rate, and storage resource utilization rate;

[0088] Inputting the task execution timing features into a deep reinforcement learning network, the network uses a temporal difference learning method to calculate a task timeliness score based on the deviation between the task completion time and the expected completion time, calculates an accuracy score based on the consistency between the execution result and the standard result, and calculates a resource utilization efficiency score based on the comparison of resource occupancy rate with the benchmark value;

[0089] Extracting agent collaboration data from the historical task execution records, including the frequency of data interaction with other agents, the amount of data transmitted, and the quality of collaborative task completion; analyzing the collaborative behavior patterns of the agents using a graph attention network, and calculating the adaptability score of the agents in the collaborative scenario. The adaptability score is based on a comprehensive assessment of the collaborative task completion efficiency, data interaction efficiency, and collaborative fault tolerance.

[0090] Input the task timeliness score, accuracy score, resource utilization efficiency score and adaptability score into the evaluation fusion network, which adopts a dynamic weight adaptive mechanism to dynamically adjust the weight coefficient of each score according to the current task characteristics and output a dynamic comprehensive score of the agent;

[0091] Receive the task execution status data of the intelligent agent in real time, update the timing characteristics and collaboration data when a new execution record is generated, recalculate the scores, and adjust the dynamic comprehensive score in real time.

[0092] In this embodiment, a deep reinforcement learning-based intelligent agent evaluation system is described in detail. The system can dynamically calculate the comprehensive score of the intelligent agent for task allocation decision-making.

[0093] The system in this embodiment first receives candidate agent set information, which is transmitted in JSON format via the system's data receiving module. Taking agent A as an example, its historical task execution records contain the following data: task start time "2023-10-01 08:00:00", completion time "2023-10-01 09:30:00", execution result "recognition accuracy 98.5%", peak CPU resource consumption 45%, memory usage 60%, number of data interactions with agent B 12 times, and total data transmission volume 250MB. The system's data preprocessing module extracts temporal features from these records and calculates the task execution duration to be 90 minutes, response latency 5 seconds, accuracy 98.5%, computing resource utilization 45%, and storage resource utilization 60%.

[0094] The extracted temporal features are transmitted to the deep reinforcement learning network via a feature processing interface for scoring calculation. The network adopts a four-layer structure, including an input layer, two hidden layers, and an output layer. The input layer receives the temporal feature vector. The first hidden layer contains 128 neurons and uses the ReLU activation function; the second hidden layer contains 64 neurons, also using the ReLU activation function; and the output layer contains three neurons, corresponding to three scoring metrics. For agent A, the network calculated a timeliness score of 92 points based on a comparison of the expected task completion time of 100 minutes with the actual completion time of 90 minutes. The accuracy score was calculated as 95 points by comparing the consistency of the execution result of 98.5% with the standard result of 99%. The resource utilization efficiency score was calculated as 89 points based on a comparison of the CPU resource utilization rate of 45% with the baseline value of 50%, and the storage resource utilization rate of 60% with the baseline value of 65%.

[0095] The system also extracts agent collaboration data from historical records. For agent A, this includes 12 data interactions with agent B, 250MB of data transmission, and a collaborative task completion quality score of 4.5 / 5. The system's graph attention network module analyzes this data, which consists of three layers of graph convolution layers, each followed by an attention mechanism layer. The nodes in the graph structure represent agents, and the edges represent collaborative relationships. The weight of the edges is determined by the frequency of interaction and the amount of data transmission. By analyzing the position and connection characteristics of agent A in the collaborative network, the system calculates its adaptability score in the collaborative scenario as 87 points. This score comprehensively considers the efficiency of collaborative task completion (weight 0.4), data interaction efficiency (weight 0.3) and collaborative fault tolerance (weight 0.3).

[0096] The evaluation fusion network receives these four scores as input. It employs a three-layer, fully connected network structure with 32 neurons in the middle layer and 16 neurons in the middle layer, using the Tanh activation function. The network's dynamic weight adaptation mechanism adjusts the weights of each score based on the current task characteristics. For example, for time-sensitive tasks, the weight of the timeliness score might be increased from the standard 0.25 to 0.4, while the weights of other indicators are correspondingly reduced. For the evaluation of Agent A, based on the current task characteristics, the system dynamically calculates the following weights: 0.3 for timeliness, 0.35 for accuracy, 0.2 for resource efficiency, and 0.15 for adaptability. Based on these weights and the corresponding scores, the system calculates a dynamic composite score of 91.75 for Agent A.

[0097] The system continuously receives execution status data from the agents through the real-time monitoring module. When agent A completes a new task and generates a new execution record—for example, if the new task takes 80 minutes to execute, accuracy improves to 99%, and resource utilization decreases to 40%—the system automatically updates the timing features and collaboration data. The deep reinforcement learning network recalculates various scores: timeliness improves to 95, accuracy improves to 98, and resource utilization efficiency improves to 92. Simultaneously, due to improved collaboration performance, the adaptability score is updated to 90. The evaluation fusion network readjusts the weights based on the current task characteristics, calculating an updated dynamic composite score of 94.65.

[0098] The system's data storage module stores scoring history in a distributed database, supporting time series analysis. For example, Agent A's score trends over the past 30 days show a steady upward trend in accuracy, from an initial 92 to its current 98; its resource utilization efficiency score, on the other hand, has fluctuated significantly, ranging from 85 to 92. This historical data is displayed as a line chart through the system's visualization interface, allowing system administrators to monitor changes in agent performance and make necessary adjustments.

[0099] Through the above implementation methods, the system can conduct a comprehensive and dynamic evaluation of candidate agents, providing a reliable decision-making basis for agent selection and task allocation.

[0100] In an optional embodiment, based on the dynamic comprehensive score, a greedy algorithm is used to select the agent with the highest score for each subtask in the subtask execution sequence, while considering the task parallel processing capability of the agent, and generating an initial agent scheduling plan includes:

[0101] Receive a subtask execution sequence and a dynamic comprehensive score of a candidate agent, wherein the subtask execution sequence includes the execution order of multiple subtasks to be executed and the dependencies between tasks; obtain task parallel processing capability information of the candidate agent, wherein the task parallel processing capability information includes the maximum number of parallel tasks, task switching overhead, and resource isolation level;

[0102] A task execution directed acyclic graph is constructed based on task dependencies, where nodes represent subtasks and edges represent dependencies and data flows between tasks. A topological sorting algorithm is used to determine task groups that can be executed in parallel. Each task group in the task execution directed acyclic graph is traversed, and the following operations are performed on the subtasks in each task group: candidate agents are traversed in descending order of dynamic comprehensive scores. The current task load of the candidate agent is checked to see if it is less than its maximum number of parallel tasks. The candidate agent is verified to see if it meets the resource isolation requirements of the subtask. When a candidate agent that meets the conditions is found, the task switching overhead and resource scheduling overhead of the agent in executing the current subtask are calculated. Combined with the dynamic comprehensive score, a multi-objective greedy strategy is used to determine the optimal agent, and the selected agent is assigned to the current subtask.

[0103] For the subtasks to which the intelligent agent has been assigned, scheduling configuration information is generated, and the scheduling configuration information includes the intelligent agent startup parameters, resource quota, data exchange interface and task switching strategy; the intelligent agent allocation results and scheduling configuration information of all subtasks are summarized to form an initial intelligent agent scheduling plan, and the initial intelligent agent scheduling plan includes a task-agent mapping relationship table, a resource allocation plan and a scheduling timing table.

[0104] #Specific implementation of the greedy algorithm agent scheduling solution generation method based on dynamic comprehensive score

[0105] In this embodiment, based on the dynamic comprehensive score, a greedy algorithm is used to select the agent with the highest score for each subtask in the subtask execution sequence, while considering the agent's task parallel processing capability. The process of generating the initial agent scheduling plan is as follows.

[0106] The system receives subtask execution sequences and dynamic composite scores for candidate agents. The subtask execution sequence is stored in JSON format, containing the execution order of multiple pending subtasks and the dependencies between them. For example, subtask T1 depends on the completion of T0 before it can be executed, represented as {"id":"T1","dep endencies":["T0"]}. The dynamic composite scores of candidate agents are calculated by the preprocessing module and stored as key-value pairs, such as {"Agent1":{"T1":0.85,"T2":0.92},"Agent2":{"T1":0.78,"T2":0.65}}, indicating that Agent 1 scored 0.85 for executing T1 and 0.92 for executing T2.

[0107] The system obtains the candidate agent's task parallel processing capability information. This information includes the maximum number of parallel tasks, task switching overhead, and resource isolation level. For example, if Agent 1's parallel processing capability is configured as {"maxParallelTasks":3,"switchOverhead":0.05,"isolationLevel":2}, it means that Agent 1 can process up to three tasks simultaneously, has a task switching overhead of 0.05 time units, and a resource isolation level of 2 (medium isolation level).

[0108] The system constructs a directed acyclic graph of task execution based on task dependencies. Nodes in the graph represent subtasks, and edges represent dependencies and data flows between tasks. For example, if T1 depends on T0, a directed edge from T0 to T1 is created in the graph. Adjacency lists are used to store the graph structure. For example, {T0:[T1,T2],T1:[T3],T2:[T3]} indicates that T1 and T2 depend on T0, while T3 depends on T1 and T2. Topological sorting is implemented using the Kahn algorithm to determine the group of tasks that can be executed in parallel. For the above example, the sorting result is [[T0],[T1,T2],[T3]], indicating that T0 must be executed first, T1 and T2 can be executed in parallel, and T3 is executed last.

[0109] The system traverses each task group in the task execution directed acyclic graph and performs scheduling operations on the subtasks in each task group. For task group [T1, T2], the system first processes T1: it traverses the candidate agents in order of dynamic comprehensive scores from high to low, assuming the order is [Agent1(0.85), Agent3(0.82), Agent2(0.78)]. Check whether Agent1's current task load (1) is less than its maximum number of parallel tasks (3), and the condition is met. Verify whether Agent1's resource isolation level (2) meets the requirements of T1 (1), and the condition is met. Calculate the task switching overhead of Agent1 executing T1 as 0.05 units of time and the resource scheduling overhead as 0.02 units of time. Taking into account the dynamic score and various overheads, determine that Agent1 is the optimal execution agent for T1 and assign it to T1. Similarly, process T2, which may be assigned to Agent1 or other qualified agents.

[0110] For the subtasks assigned to an agent, the system generates scheduling configuration information. For example, the configuration information assigned to Agent1 by T1 is {"agentId":"Agent1","taskId":"T1","startupParameters":{"priority":1,"timeout":300},"resourceQuota":{"cpu":"2cores","memory":"4GB"},"dataInterfaces":{"input":"queue1","output":"queue2"},"switchStrategy":"preemptive"}, which includes agent startup parameters, resource quotas, data exchange interfaces, and task switching strategies.

[0111] Finally, the system summarizes the agent allocation results and scheduling configuration information of all subtasks to form an initial agent scheduling plan. The scheme includes a task-agent mapping relationship table, such as {"T0":"Agent2","T1":"Agent1","T2":"Agent1","T3":"Agent3"}; a resource allocation scheme, such as {"Agent1":{"cpu":"4cores","memory":"8GB"},"Agent2":{"cpu":"2cores","memory":"4GB"},"Agent3":{"cpu":"3cores","memory":"6GB"}}; and a scheduling sequence table, such as [{"time":0,"tasks":["T0"]},{"time":50,"tasks":["T1","T2"]},{"time":120,"tasks":["T3"]}], indicating that T0 starts executing at time 0, T1 and T2 start executing in parallel at time 50, and T3 starts executing at time 120.

[0112] Through this implementation, the system uses a greedy algorithm to select the most suitable agent for each subtask in the subtask execution sequence based on dynamic comprehensive scores and the agent's task parallel processing capabilities, generating an efficient initial agent scheduling solution. This solution balances task execution efficiency, resource utilization, and system load balancing, providing a reliable scheduling foundation for the coordinated execution of complex tasks by agents.

[0113] In an optional embodiment, the agents selected in the initial agent scheduling scheme and the data interaction relationships between them are mapped into a collaborative graph. The nodes in the graph represent agents, the edges represent data transmission between agents, and the weights of the edges represent data transmission overhead. The collaborative graph is analyzed using a graph neural network to predict the collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the selection of agents and the data transmission path are optimized using a graph structure optimization algorithm until the predicted efficiency meets the requirements. The final scheduling scheme includes:

[0114] Receive the initial agent scheduling plan, extract the agent selection results and task allocation information from it, and determine the data interaction relationship between agents based on the task allocation information; use the selected agents as nodes and the data interaction relationships as connecting edges to generate an initial collaborative graph, and at the same time extract the historical data transmission records between agents from the system operation log;

[0115] Based on the historical data transmission records, the latency characteristics, bandwidth occupancy characteristics, and transmission reliability characteristics of each data transmission edge are calculated, and these characteristic values ​​are added to the collaborative graph as edge weight attributes;

[0116] The graph attention mechanism is used to analyze the connectivity distribution of nodes, the clustering coefficient of edges, and the path complexity in the collaborative graph. These graph structural features are input into a pre-trained efficiency prediction network, which outputs a collaborative execution efficiency prediction value. The efficiency prediction value represents the overall performance of the collaborative execution of tasks by the agents under the current scheduling scheme.

[0117] Compare the predicted efficiency value with the system's preset efficiency target threshold. When the predicted value is lower than the threshold, locate the efficiency bottleneck based on the graph attention analysis results, and find the data transmission hotspot areas and paths with high transmission overhead;

[0118] For identified efficiency bottlenecks, agents with better performance are selected from the candidate agent pool to replace bottleneck nodes. At the same time, data transmission paths are adjusted to reduce cross-node data transmission through the principle of proximity allocation. A data caching mechanism is established between nodes with frequent data interaction to achieve local storage and fast access to data.

[0119] The collaborative graph is regenerated using the updated agent selection scheme and data transmission strategy, and the efficiency prediction network is reused to calculate a new efficiency prediction value. When the prediction value continues to be lower than the threshold, the optimization steps are repeated until the efficiency prediction value meets the requirements.

[0120] Output the final optimized scheduling plan, which includes the optimized agent selection results, data transmission routing strategy and collaborative scheduling mechanism, and send these configuration information to the task execution engine for deployment.

[0121] This embodiment provides an agent collaborative scheduling optimization method based on graph neural network. The method optimizes agent selection and data transmission path by constructing a collaborative graph and using graph neural network analysis to predict collaborative execution efficiency.

[0122] The system first receives an initial agent scheduling plan, which includes agent selection results and task assignment information. For example, in a system consisting of 10 agent nodes, the initial plan selects five agents—A, B, C, D, and E—to perform data analysis tasks. A is responsible for data acquisition, B and C for feature extraction, D for model inference, and E for result integration. Based on this task assignment information, the system extracts the data interaction relationships between agents. For example, A needs to transmit raw data to B and C, B and C need to transmit feature data to D, and D needs to transmit inference results to E.

[0123] When constructing the collaborative graph, the system uses the selected agents A, B, C, D, and E as nodes in the graph and represents the data interactions between them as edges, generating an initial collaborative graph. Simultaneously, the system extracts data transmission records between these agents over the past 30 days from historical operation logs, including information such as transmission time, data size, and transmission success rate.

[0124] Based on historical data transmission records, the system calculates the weight attributes of each data transmission edge. For example, the data transmission edge from A to B has the following characteristics: average latency of 15 milliseconds, bandwidth utilization of 8 MB / s, and transmission reliability of 99.5%; the data transmission edge from A to C has an average latency of 25 milliseconds, bandwidth utilization of 10 MB / s, and transmission reliability of 98.7%; the data transmission edge from B to D has an average latency of 12 milliseconds, bandwidth utilization of 5 MB / s, and transmission reliability of 99.8%; the data transmission edge from C to D has an average latency of 18 milliseconds, bandwidth utilization of 6 MB / s, and transmission reliability of 99.2%; and the data transmission edge from D to E has an average latency of 8 milliseconds, bandwidth utilization of 3 MB / s, and transmission reliability of 99.9%. The system adds these characteristic values ​​as edge weight attributes to the collaborative graph.

[0125] The system uses a graph attention mechanism to analyze the structural features in the collaborative graph. In this example, the system calculated the following node connectivity distribution: A has a connectivity of 2, B and C have a connectivity of 2, D has a connectivity of 3, and E has a connectivity of 1. The average clustering coefficient of the graph is 0.35, the longest path length is 3, and the average path length is 1.8. These graph structural features are input into a pre-trained efficiency prediction network, which consists of three graph convolutional layers and two fully connected layers and has been pre-trained using historical task execution data. The efficiency prediction network outputs a predicted collaborative execution efficiency value of 0.72 under the current scheduling scheme, while the system's preset efficiency target threshold is 0.85.

[0126] Because the predicted efficiency value of 0.72 is lower than the target threshold of 0.85, the system identifies efficiency bottlenecks based on graph attention analysis. This analysis shows that the data transmission path from A to C has high latency (25 milliseconds) and low reliability (98.7%), becoming a bottleneck for overall efficiency. Furthermore, node D has a high connectivity (connectivity of 3), making it a data transmission hotspot.

[0127] To address the identified efficiency bottleneck, the system selected agent F, a higher-performing agent, from a pool of candidate agents to replace node C. The historical average latency between F and A was 10 milliseconds, bandwidth usage was 9 MB / s, and transmission reliability was 99.6%, significantly superior to node C. Simultaneously, the system established a data caching mechanism between A and D, enabling B and F to read A's data from their local cache, reducing duplicate transmissions. Furthermore, the system adjusted the data transmission path, adopting A→B→D and A→F→D, to avoid congestion caused by node D communicating directly with too many nodes.

[0128] Using the updated solution, the system regenerated the collaborative graph, which now includes nodes A, B, D, E, and F, along with the optimized data transmission path. The system's reuse efficiency prediction network calculated a new efficiency prediction of 0.81, which, while an improvement, remained below the target threshold of 0.85. Continuing optimization, the system discovered that node D's computing power might be insufficient. It then selected agent G, a higher-performing agent, from the candidate pool to replace it. Node G's processing speed was 30% faster than D's, and its connection latency to nodes B, F, and E was less than 10 milliseconds.

[0129] The final optimized solution included agents A, B, F, G, and E, with data transmission paths A→B→G, A→F→G, and G→E. A data caching mechanism was established between each node. The predicted efficiency of this solution reached 0.89, exceeding the target threshold of 0.85. The system then distributed the final optimized scheduling solution to the task execution engine for deployment, including the agent selection results (A, B, F, G, and E), the data transmission routing strategy, and detailed configuration parameters for the collaborative scheduling mechanism.

[0130] Actual operational results show that compared to the initial solution, the optimized solution reduced task execution time from 120 seconds to 78 seconds, a 35% improvement; improved system resource utilization from 65% to 83%; and reduced total data transmission from 1.2GB to 0.85GB, a 29% reduction. This validates the effectiveness of the graph neural network-based agent collaborative scheduling optimization method.

[0131] In an optional embodiment, according to the agent selection results and data interaction paths in the final scheduling plan, the corresponding agents are started and data transmission channels are established. The agents begin to collaboratively execute tasks according to the subtask execution sequence, and the execution status and collaborative effect of the agents are monitored in real time. When an execution anomaly or collaborative anomaly of the agent is detected, the anomaly information is fed back to the agent evaluation model to update the dynamic comprehensive score, and the emergency scheduling mechanism is triggered to re-select the agent and generate the collaborative plan, including:

[0132] Receive the final scheduling plan, extract the agent selection results and task allocation information, send the agent startup instruction to the target computing node, and configure the data transmission channel between agents according to the data interaction path, and allocate corresponding computing resources, network bandwidth and cache space to each channel;

[0133] Deploy a status monitoring probe in the running environment of each agent, which continuously collects the agent's computing load data, memory usage data, response latency data, data throughput data, and collaborative message data;

[0134] The collected status data is transmitted to the monitoring center in real time. The monitoring center calculates the normal value range of each indicator based on historical operation data and detects indicator anomalies through a sliding time window. When a certain indicator exceeds the normal range, the complete status data at the time of the anomaly is extracted to generate an anomaly feature vector.

[0135] According to the subtask execution sequence, the agent is triggered to execute tasks in sequence. The agent obtains input data through the pre-established data transmission channel, and after processing, transmits the output data to the downstream agent through the specified channel;

[0136] Analyze the abnormal feature vector in real time, match the feature vector with the abnormal pattern in the historical anomaly database for similarity, determine the abnormal level according to the matching result, and determine the abnormal impact range based on the abnormal propagation path analysis. Adopt differentiated processing strategies for different abnormal levels: dynamically adjust the resource quota and operating parameters of the abnormal agent in case of minor anomalies; reduce the dynamic score of the abnormal agent and shrink its task allocation scope in case of moderate anomalies; activate alternative agents to complete task migration and take over in case of severe anomalies.

[0137] Example

[0138] This embodiment provides a method for intelligent agents to collaboratively perform tasks, which is described in detail below with reference to specific technical details.

[0139] After the final schedule is determined, the system parses the schedule document to extract the agent selection results and their corresponding task assignment information. This document, formatted in JSON, contains agent identifiers, deployment locations, task descriptions, resource requirements, and data interaction paths. For example, for a document retrieval task, the system might select a combination of document preprocessing agent A, feature extraction agent B, retrieval matching agent C, and result ranking agent D. The system then sends a startup command to the compute nodes hosting these agents via remote procedure calls. The command includes a task description, resource configuration parameters, and data interface definitions.

[0140] Data transmission channels are configured based on an efficient point-to-point communication mechanism. The system allocates 10Mbps of dedicated bandwidth and 512MB of shared memory for data transmission between agents A and B, with a data transmission timeout threshold of 200 milliseconds. The system also creates a data buffer for each channel. The buffer size is dynamically adjusted based on historical data traffic, initially set to 128MB. When the buffer utilization exceeds 85%, the system automatically expands to 1.5 times the current size, up to a maximum of 1GB.

[0141] The status monitoring probe deployed in the intelligent agent's operating environment is based on a lightweight agent architecture. The probe program occupies no more than 50MB of memory and has a CPU usage rate of less than 1%, ensuring that the impact on the intelligent agent's performance is minimized. The probe collects system status data every 100 milliseconds, including indicators such as CPU usage, memory usage, disk I / O rate, network traffic, and response latency. At the same time, the probe also monitors the call status of the intelligent agent's key functions through hook functions, recording function execution time, parameter size, and return value type. After preliminary local processing, the collected data is transmitted to the monitoring center in a compressed binary format with a compression rate of up to 70%, effectively reducing the burden on network transmission.

[0142] The monitoring center receives status data from each probe and applies an adaptive anomaly detection algorithm to analyze the operating status. The system calculates the normal value range for each indicator based on historical data from the past 7 days. For example, the normal range of memory usage of document preprocessing agent A is 30%-65%, and the normal range of response delay is 50-150 milliseconds. The system uses a 60-second sliding time window to continuously monitor various indicators. When it detects that the response delay of feature extraction agent B exceeds the normal upper limit of 200 milliseconds for 5 consecutive times, the system extracts the complete status data at the time of the abnormality, including information such as CPU usage of 82%, memory usage of 75%, and the number of queue backlog tasks of 35, and generates an abnormal feature vector containing 12 dimensions.

[0143] During task execution, each agent works collaboratively, strictly following a predetermined execution sequence. After document preprocessing agent A completes text cleaning and standardization, it transmits the results (including the cleaned text content and metadata) to feature extraction agent B via a pre-established data transmission channel. After receiving the data, agent B verifies its integrity, extracts the document's feature vector, and then transmits it to retrieval and matching agent C. Throughout the data transmission process, the system records the transmission time, size, and integrity check results of each data packet to ensure that data is not lost or damaged during transmission.

[0144] The monitoring center analyzes detected anomaly feature vectors in real time and compares them against a historical anomaly database containing over 500 typical anomaly patterns. This matching is performed using cosine similarity, with a similarity threshold of 0.85. For example, when feature extraction agent B experiences an abnormal response delay, the system compares its anomaly feature vector with historical data and finds a similarity of 0.92 with a "performance degradation caused by memory leak" pattern, identifying it as a moderate anomaly. The system further analyzes the potential impact of this anomaly on downstream agents C and D, estimating that the anomaly's impact covers 40% of subsequent task processing.

[0145] The system adopts differentiated processing strategies for different levels of anomalies. For minor anomalies (similarity 0.85-0.9 or impact range less than 20%), such as the CPU usage of the retrieval and matching agent C temporarily rising to 75%, the system dynamically increases its CPU quota from 2 cores to 3 cores and adjusts the task batch size from 50 to 30. For moderate anomalies (similarity 0.9-0.95 or impact range 20%-50%), such as the memory leak problem of the feature extraction agent B, the system reduces its dynamic score from 85 to 70 points, reduces its task load by 30%, and assigns it to the alternative agent B2 for processing. For severe anomalies (similarity greater than 0.95 or impact range greater than 50%), such as the complete unresponsiveness of the document preprocessing agent A, the system immediately starts the alternative agent A2, migrates the unprocessed data and status to A2, and A2 takes over the remaining tasks. The entire migration process takes no more than 2 seconds to ensure continuous execution of tasks.

[0146] Through the coordinated application of the above-mentioned technical means, the system can efficiently start and manage intelligent agents, establish reliable data transmission channels, monitor the operating status of intelligent agents in real time, accurately identify and handle various abnormal situations, and ensure the stable operation of the multi-agent system and the smooth completion of tasks.

[0147] The embodiment of the present invention is a large-model intelligent agent collaborative scheduling system for complex tasks, the system comprising:

[0148] The first unit is configured to receive a complex task input by a user and, based on semantic analysis and task dependency analysis, decompose the complex task into multiple subtasks with a sequential execution order to obtain a subtask execution sequence; and utilize a pre-trained feature extraction model to extract feature vectors from each subtask in the subtask execution sequence based on three dimensions: task objectives, execution constraints, and resource requirements, to generate corresponding task feature vectors.

[0149] The second unit is used to input the task feature vector into the agent matching network. The network calculates the similarity between the task feature vector and the ability feature vector of each agent in the pre-built large model agent pool, and selects a set of candidate agents that meet the execution ability requirements for each subtask;

[0150] A third unit is configured to calculate, for each agent in the candidate agent set, a score for three indicators: timeliness of task completion, accuracy of results, and efficiency of resource utilization, based on its historical task execution records, using a deep reinforcement learning network. These three scores are input into a pre-trained agent evaluation model. The model comprehensively considers the historical collaborative performance of the agent and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses.

[0151] A fourth unit is configured to select the agent with the highest score for each subtask in the subtask execution sequence based on the dynamic comprehensive score using a greedy algorithm, while taking into account the task parallel processing capability of the agent, to generate an initial agent scheduling plan;

[0152] The fifth unit is configured to map the agents selected in the initial agent scheduling plan and the data interaction relationships between them into a collaborative graph, where nodes in the graph represent agents, edges represent data transmission between agents, and edge weights represent data transmission overhead. The collaborative graph is analyzed using a graph neural network to predict collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the selection of agents and data transmission paths are optimized using a graph structure optimization algorithm until the predicted efficiency meets the requirements, thereby obtaining a final scheduling plan.

[0153] The sixth unit is used to start the corresponding agent and establish a data transmission channel according to the agent selection result and data interaction path in the final scheduling plan. The agent begins to collaboratively execute tasks according to the subtask execution sequence, monitors the execution status and collaborative effect of the agent in real time, and when it detects that the agent has an execution abnormality or collaborative abnormality, feeds the abnormal information back to the agent evaluation model to update the dynamic comprehensive score, and triggers the emergency scheduling mechanism to re-select the agent and generate a collaborative plan. The third aspect of the embodiment of the present invention provides an electronic device, including:

[0154] processor;

[0155] a memory for storing processor-executable instructions;

[0156] The processor is configured to call the instructions stored in the memory to execute the aforementioned method.

[0157] According to a fourth aspect of an embodiment of the present invention, a computer-readable storage medium is provided, on which computer program instructions are stored. When the computer program instructions are executed by a processor, the method described above is implemented.

[0158] The present invention may be a method, an apparatus, a system and / or a computer program product. The computer program product may include a computer-readable storage medium carrying computer-readable program instructions for executing various aspects of the present invention.

[0159] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the above embodiments, or replace some or all of the technical features therein with equivalents. However, these modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of the present invention.

Claims

1. A large-scale intelligent agent collaborative scheduling method for complex tasks, characterized by: include: Receive a complex task input by the user, and based on semantic analysis and task dependency analysis, decompose the complex task into multiple subtasks with a certain execution order to obtain a subtask execution sequence; use a pre-trained feature extraction model to extract feature vectors for each subtask in the subtask execution sequence from three dimensions: task goal, execution constraint, and resource requirement, and generate corresponding task feature vectors; The task feature vector is input into the agent matching network, which calculates the similarity between the task feature vector and the capability feature vector of each agent in the pre-built large model agent pool, and selects a set of candidate agents that meet the execution capability requirements for each subtask; For each agent in the candidate agent set, a deep reinforcement learning network is used to calculate scores for three indicators: timeliness of task completion, accuracy of results, and efficiency of resource utilization, based on its historical task execution records. These three scores are input into a pre-trained agent evaluation model, which comprehensively considers the agent's historical collaborative performance and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses. Based on the dynamic comprehensive score, a greedy algorithm is used to select the agent with the highest score for each subtask in the subtask execution sequence, while taking into account the task parallel processing capability of the agent to generate an initial agent scheduling plan; The agents selected in the initial agent scheduling scheme and the data interaction relationships between them are mapped into a collaborative graph, where nodes in the graph represent agents, edges represent data transmission between agents, and edge weights represent data transmission overhead. The collaborative graph is analyzed using a graph neural network to predict the collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the selection of agents and the data transmission path are optimized using a graph structure optimization algorithm until the predicted efficiency meets the requirements, thereby obtaining a final scheduling scheme. According to the agent selection results and data interaction paths in the final scheduling plan, the corresponding agents are started and data transmission channels are established. The agents begin to collaboratively execute tasks according to the subtask execution sequence, and the execution status and collaborative effects of the agents are monitored in real time. When execution anomalies or collaborative anomalies of the agents are detected, the abnormal information is fed back to the agent evaluation model to update the dynamic comprehensive score, and the emergency scheduling mechanism is triggered to re-select agents and regenerate collaborative plans.

2. The method according to claim 1, characterized in that The task feature vector is input into the agent matching network. The network calculates the similarity between the task feature vector and the capability feature vector of each agent in the pre-built large model agent pool. The candidate agent set that meets the execution capability requirements for each subtask is selected, including: Obtain an input task feature vector, the task feature vector including task objective features, execution constraint features, and resource requirement features; read agent pool information from a preset agent database, the information of each agent in the agent pool including agent identification, function description, call interface, hardware requirements, and capability feature vector; calculate the similarity value between the task feature vector and the capability feature vector of each agent in the agent pool based on the cosine similarity algorithm to generate a task-agent similarity matrix; According to the task-agent similarity matrix, a similarity threshold is set, and the optimal similarity threshold is determined through an adaptive threshold screening algorithm. Agents with similarity values ​​greater than the optimal similarity threshold are screened as candidate agents. At the same time, a matching degree is calculated based on the hardware requirements of the agents and the hardware resources of the current system, and agents whose hardware resources do not meet the requirements are eliminated; For the selected candidate agents, obtain their historical call records, which include call time, execution status, resource usage, and execution results; Analyzing the historical call records using a time series neural network to predict the reliability index of each candidate agent when performing the current task, the reliability index includes execution success rate, average response time, and resource utilization efficiency; ranking the candidate agents based on the reliability index, and selecting the top N agents to form a candidate agent set; Generate call configuration information for the candidate agent set, which includes agent identification, call interface parameters, resource quota and data interaction format; submit the candidate agent set and its call configuration information to the task scheduling module for subsequent agent collaborative scheduling.

3. The method according to claim 1, characterized in that For each agent in the candidate agent set, based on its historical task execution records, a deep reinforcement learning network is used to calculate the scores of three indicators: task completion timeliness, result accuracy, and resource utilization efficiency. These three scores are input into the pre-trained agent evaluation model. The model comprehensively considers the historical collaborative performance of the agent and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses. It includes: Receive candidate agent set information and obtain historical task execution records for each candidate agent, wherein the historical task execution records include task start time, completion time, execution results, resource consumption data, and collaborative interaction data; extract task execution timing features from the historical task execution records, including task execution duration, task response delay, execution result accuracy, computing resource occupancy rate, and storage resource utilization rate; Inputting the task execution timing features into a deep reinforcement learning network, the network uses a temporal difference learning method to calculate a task timeliness score based on the deviation between the task completion time and the expected completion time, calculates an accuracy score based on the consistency between the execution result and the standard result, and calculates a resource utilization efficiency score based on the comparison of resource occupancy rate with the benchmark value; Extracting agent collaboration data from the historical task execution records, including the frequency of data interaction with other agents, the amount of data transmitted, and the quality of collaborative task completion; analyzing the collaborative behavior patterns of the agents using a graph attention network, and calculating the adaptability score of the agents in the collaborative scenario. The adaptability score is based on a comprehensive assessment of the collaborative task completion efficiency, data interaction efficiency, and collaborative fault tolerance. Input the task timeliness score, accuracy score, resource utilization efficiency score and adaptability score into the evaluation fusion network, which adopts a dynamic weight adaptive mechanism to dynamically adjust the weight coefficient of each score according to the current task characteristics and output a dynamic comprehensive score of the agent; Receive the task execution status data of the intelligent agent in real time, update the timing characteristics and collaboration data when a new execution record is generated, recalculate the scores, and adjust the dynamic comprehensive score in real time.

4. The method according to claim 1, wherein Based on the dynamic comprehensive score, a greedy algorithm is used to select the agent with the highest score for each subtask in the subtask execution sequence. At the same time, the task parallel processing capability of the agent is taken into consideration to generate an initial agent scheduling scheme including: Receive a subtask execution sequence and a dynamic comprehensive score of a candidate agent, wherein the subtask execution sequence includes the execution order of multiple subtasks to be executed and the dependencies between tasks; obtain task parallel processing capability information of the candidate agent, wherein the task parallel processing capability information includes the maximum number of parallel tasks, task switching overhead, and resource isolation level; A directed acyclic graph (DAG) of task execution is constructed based on task dependencies. Nodes in the graph represent subtasks, and edges represent dependencies and data flows between tasks. A topological sorting algorithm is used to determine groups of tasks that can be executed in parallel. Each task group in the DAG is traversed, and the following operations are performed on the subtasks in each task group: Traverse candidate agents in descending order of dynamic comprehensive scores; check whether the current task load of the candidate agent is less than its maximum number of parallel tasks; verify whether the candidate agent meets the resource isolation requirements of the subtask; when a candidate agent that meets the conditions is found, calculate the task switching cost and resource scheduling cost of the agent executing the current subtask, combine the dynamic comprehensive score, use a multi-objective greedy strategy to determine the optimal agent, and assign the selected agent to the current subtask; For the subtasks to which the intelligent agent has been assigned, scheduling configuration information is generated, and the scheduling configuration information includes the intelligent agent startup parameters, resource quota, data exchange interface and task switching strategy; the intelligent agent allocation results and scheduling configuration information of all subtasks are summarized to form an initial intelligent agent scheduling plan, and the initial intelligent agent scheduling plan includes a task-agent mapping relationship table, a resource allocation plan and a scheduling timing table.

5. The method according to claim 1, wherein The agents selected in the initial agent scheduling scheme and the data interaction relationships between them are mapped into a collaborative graph. The nodes in the graph represent agents, the edges represent data transmission between agents, and the weights of the edges represent the data transmission overhead. The collaborative graph is analyzed through a graph neural network to predict the collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the graph structure optimization algorithm is used to optimize the agent selection and data transmission path until the predicted efficiency meets the requirements. The final scheduling scheme includes: Receive the initial agent scheduling plan, extract the agent selection results and task allocation information from it, and determine the data interaction relationship between agents based on the task allocation information; use the selected agents as nodes and the data interaction relationships as connecting edges to generate an initial collaborative graph, and at the same time extract the historical data transmission records between agents from the system operation log; Based on the historical data transmission records, the latency characteristics, bandwidth occupancy characteristics, and transmission reliability characteristics of each data transmission edge are calculated, and these characteristic values ​​are added to the collaborative graph as edge weight attributes; The graph attention mechanism is used to analyze the connectivity distribution of nodes, the clustering coefficient of edges, and the path complexity in the collaborative graph. These graph structural features are input into a pre-trained efficiency prediction network, which outputs a collaborative execution efficiency prediction value. The efficiency prediction value represents the overall performance of the collaborative execution of tasks by the agents under the current scheduling scheme. Compare the predicted efficiency value with the system's preset efficiency target threshold. When the predicted value is lower than the threshold, locate the efficiency bottleneck based on the graph attention analysis results, and find the data transmission hotspot areas and paths with high transmission overhead; For identified efficiency bottlenecks, agents with better performance are selected from the candidate agent pool to replace bottleneck nodes. At the same time, data transmission paths are adjusted to reduce cross-node data transmission through the principle of proximity allocation. A data caching mechanism is established between nodes with frequent data interaction to achieve local storage and fast access to data. The collaborative graph is regenerated using the updated agent selection scheme and data transmission strategy, and the efficiency prediction network is reused to calculate a new efficiency prediction value. When the prediction value continues to be lower than the threshold, the optimization steps are repeated until the efficiency prediction value meets the requirements. Output the final optimized scheduling plan, which includes the optimized agent selection results, data transmission routing strategy and collaborative scheduling mechanism, and send these configuration information to the task execution engine for deployment.

6. The method according to claim 1, characterized in that According to the agent selection results and data interaction paths in the final scheduling plan, the corresponding agents are started and data transmission channels are established. The agents begin to collaboratively execute tasks according to the subtask execution sequence, and the execution status and collaborative effects of the agents are monitored in real time. When an execution anomaly or collaborative anomaly is detected in the agent, the anomaly information is fed back to the agent evaluation model to update the dynamic comprehensive score, and the emergency scheduling mechanism is triggered to re-select the agent and generate a collaborative plan, including: Receive the final scheduling plan, extract the agent selection results and task allocation information, send the agent startup instruction to the target computing node, and configure the data transmission channel between agents according to the data interaction path, and allocate corresponding computing resources, network bandwidth and cache space to each channel; Deploy a status monitoring probe in the running environment of each agent, which continuously collects the agent's computing load data, memory usage data, response latency data, data throughput data, and collaborative message data; The collected status data is transmitted to the monitoring center in real time. The monitoring center calculates the normal value range of each indicator based on historical operation data and detects indicator anomalies through a sliding time window. When a certain indicator exceeds the normal range, the complete status data at the time of the anomaly is extracted to generate an anomaly feature vector. According to the subtask execution sequence, the agent is triggered to execute tasks in sequence. The agent obtains input data through the pre-established data transmission channel, and after processing, transmits the output data to the downstream agent through the specified channel; Analyze the abnormal feature vector in real time, match the feature vector with the abnormal pattern in the historical anomaly database for similarity, determine the abnormal level according to the matching result, and determine the abnormal impact range based on the abnormal propagation path analysis. Adopt differentiated processing strategies for different abnormal levels: dynamically adjust the resource quota and operating parameters of the abnormal agent in case of minor anomalies; reduce the dynamic score of the abnormal agent and shrink its task allocation scope in case of moderate anomalies; activate alternative agents to complete task migration and take over in case of severe anomalies.

7. A large-scale intelligent agent collaborative scheduling system for complex tasks, used to implement the method according to any one of claims 1 to 6, characterized in that: include: The first unit is configured to receive a complex task input by a user and, based on semantic analysis and task dependency analysis, decompose the complex task into multiple subtasks with a sequential execution order to obtain a subtask execution sequence; and utilize a pre-trained feature extraction model to extract feature vectors from each subtask in the subtask execution sequence based on three dimensions: task objectives, execution constraints, and resource requirements, to generate corresponding task feature vectors. The second unit is used to input the task feature vector into the agent matching network. The network calculates the similarity between the task feature vector and the ability feature vector of each agent in the pre-built large model agent pool, and selects a set of candidate agents that meet the execution ability requirements for each subtask; A third unit is configured to calculate, for each agent in the candidate agent set, a score for three indicators: timeliness of task completion, accuracy of results, and efficiency of resource utilization, based on its historical task execution records, using a deep reinforcement learning network. These three scores are input into a pre-trained agent evaluation model. The model comprehensively considers the historical collaborative performance of the agent and outputs a dynamic comprehensive score for the agent. The dynamic comprehensive score is updated in real time as the agent's task execution progresses. A fourth unit is configured to select the agent with the highest score for each subtask in the subtask execution sequence based on the dynamic comprehensive score using a greedy algorithm, while taking into account the task parallel processing capability of the agent, to generate an initial agent scheduling plan; The fifth unit is configured to map the agents selected in the initial agent scheduling plan and the data interaction relationships between them into a collaborative graph, where nodes in the graph represent agents, edges represent data transmission between agents, and edge weights represent data transmission overhead. The collaborative graph is analyzed using a graph neural network to predict collaborative execution efficiency. When the predicted efficiency is lower than a preset threshold, the selection of agents and data transmission paths are optimized using a graph structure optimization algorithm until the predicted efficiency meets the requirements, thereby obtaining a final scheduling plan. The sixth unit is used to start the corresponding agent and establish a data transmission channel according to the agent selection results and data interaction path in the final scheduling plan. The agent begins to collaboratively execute tasks according to the subtask execution sequence, monitors the execution status and collaborative effect of the agent in real time, and when it is detected that the agent has an execution anomaly or a collaborative anomaly, the anomaly information is fed back to the agent evaluation model to update the dynamic comprehensive score, and trigger the emergency scheduling mechanism to re-select the agent and regenerate the collaborative plan.

8. An electronic device, characterized in that: include: processor; a memory for storing processor-executable instructions; The processor is configured to call the instructions stored in the memory to execute the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having computer program instructions stored thereon, characterized in that: When the computer program instructions are executed by a processor, the method according to any one of claims 1 to 6 is implemented.

Images