Management method and system for multi-agent application integrating graph arrangement and expert ability

Abstract

The invention discloses a multi-agent application management method and system fusing graph arrangement and expert ability, belongs to the technical field of computers, and aims at locating historical experience highly related to a current task target by retrieving a historical task execution sub-graph and a success strategy mode from a coevolution knowledge graph based on graph state differences. Blind search is avoided, and the utilization efficiency and correlation of historical experience are improved. Meanwhile, candidate task flows can be generated and optimized. Reasoning is carried out by taking the historical modes as reference and combining historical efficiency data of the intelligent agent, so that a plurality of candidate task flows can be generated; the multi-scheme generation mechanism not only considers the historical success path, but also integrates the actual performance of the intelligent agent, so that the generated task flow is more diversified and adaptive, and the risk of a single scheme is reduced.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a management method and system for multi-agent applications that integrates graph arrangement and expert capabilities. Background Technology

[0002] In the technological development of multi-agent applications, existing mainstream technical solutions mainly follow two construction paradigms, but both have fundamental limitations. The static orchestration paradigm relies on pre-defined fixed workflows to constrain the collaborative logic between agents. This method struggles to adapt to the dynamic evolution of task requirements and the uncertainty of environmental conditions after deployment. For example, when user tasks involve new domain knowledge or sudden changes in scenarios, the entire workflow must be manually adjusted and reconfigured, leading to response delays, soaring maintenance costs, and severely limiting flexibility and scalability. The decentralized evolutionary paradigm emphasizes autonomous decision-making and collaboration among agents based on local information. However, due to the lack of a unified global coordination mechanism, conflicts easily arise between the goal orientations and behavioral strategies of different agents, resulting in inconsistent task execution results, unpredictable behavior, and reduced overall efficiency. This paradigm is particularly prominent when dealing with complex tasks requiring highly reliable collaboration, such as medical diagnosis and emergency response, and cannot meet the stringent requirements of controllability and behavioral traceability in practical applications.

[0003] These two paradigms respectively give rise to systemic problems of "static rigidity" and "dynamic chaos." Static rigidity manifests as an inability to learn from past tasks, requiring the redesign of collaborative logic each time a similar scenario arises. Dynamic chaos, on the other hand, is characterized by a lack of structured accumulation in collaboration among agents, resulting in fragmented and ad-hoc decision-making processes. The core contradiction lies in the fact that existing architectures cannot simultaneously achieve globally controllable orchestration capabilities and autonomous, continuous optimization capabilities based on collective experience. In practice, the decision-making experience of multi-agents is often scattered in unstructured form across various tasks, unable to be accumulated, reused, or iterated. Each task execution is isolated from past practices, causing multi-agents to quickly hit performance bottlenecks after deployment, struggling to overcome the limitations of the initial design and failing to achieve the evolutionary goal of "becoming smarter with use." This experience gap makes it impossible to maintain stability and controllability when facing complex and ever-changing task environments, and also prevents continuous learning to improve efficiency.

[0004] To address the aforementioned issues, existing technologies urgently need improvement. Summary of the Invention

[0005] This application provides a management method and system for multi-agent applications that integrate graph orchestration and expert capabilities. The technical solution is as follows: On the one hand, a management method for multi-agent applications that integrates graph orchestration and expert capabilities is provided, the method comprising: The graph state difference between the target graph state corresponding to the user task input and the current state of the co-evolutionary knowledge graph is determined, and based on the graph state difference and the agent's historical performance data recorded in the co-evolutionary knowledge graph, a graph-based task execution plan is dynamically generated through goal planning logic. Based on the graph-based task execution plan, at least one agent to be invoked is determined, and execution instructions containing relevant historical decisions and domain context are dynamically assembled for the at least one agent from the co-evolutionary knowledge graph. Obtain the structured execution results returned by at least one intelligent agent, evaluate the performance and verify the knowledge consistency of the structured execution results according to the preset evaluation rules, obtain the evaluation and verification results, and integrate the decision link formed in this task execution process into the co-evolutionary knowledge graph in the form of nodes and relationships based on the evaluation and verification results. Based on the new content and structural relationships included in the fused co-evolutionary knowledge graph, the target planning logic is optimized through feedback. Attached Figure Description

[0006] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0007] Figure 1 This is a flowchart of a management method for a multi-agent application that integrates graph orchestration and expert capabilities, provided in an embodiment of this application. Figure 2 This is a flowchart of another management method for multi-agent applications that integrates graph orchestration and expert capabilities, provided in an embodiment of this application. Figure 3 This is a flowchart of a management method for a multi-agent application that integrates graph orchestration and expert capabilities, as provided in an embodiment of this application. Figure 4 This is a flowchart of a management method for a multi-agent application that integrates graph orchestration and expert capabilities, as provided in an embodiment of this application. Figure 5 This is a flowchart of a management method for a multi-agent application that integrates graph orchestration and expert capabilities, as provided in an embodiment of this application. Figure 6 This is a flowchart of a management method for a multi-agent application that integrates graph orchestration and expert capabilities, as provided in an embodiment of this application. Figure 7This is a schematic diagram of the structure of a management system for multi-agent applications that integrates graph orchestration and expert capabilities, provided in an embodiment of this application. Detailed Implementation

[0008] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0009] In this application, the terms "first," "second," etc., are used to distinguish identical or similar items with essentially the same function. It should be understood that there is no logical or temporal dependency between "first," "second," and "nth," nor are there any restrictions on quantity or execution order.

[0010] It should be noted that the information (including but not limited to user device information, user personal information, etc.), data (including but not limited to data used for analysis, data stored, data displayed, etc.) and signals involved in this application are all authorized by the user or fully authorized by all parties, and the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions.

[0011] Traditional multi-agent applications primarily employ two paradigms during deployment: static orchestration and decentralized evolution. The static orchestration paradigm relies on predefined workflows, making it difficult to adapt to dynamically changing task requirements and environments, resulting in insufficient flexibility and scalability. While the decentralized evolution paradigm advocates autonomous agent collaboration, the lack of a global coordination hub makes it difficult to guarantee consistency of task objectives, leading to chaotic behavior and low efficiency. Neither paradigm can simultaneously achieve globally controllable orchestration and autonomous, continuous optimization based on collective experience. Decision-making experience is difficult to accumulate and reuse in a structured manner, making it challenging for multi-agent applications to achieve continuous evolution after deployment.

[0012] To address this, this application proposes a management method for multi-agent applications that integrates graph orchestration and expert capabilities; see [link to relevant documentation]. Figure 1 Taking the server as the executing entity as an example, the method includes the following steps.

[0013] 101. Determine the graph state difference between the target graph state corresponding to the user task input and the current state of the co-evolutionary knowledge graph, and based on the graph state difference and the agent's historical performance data recorded in the co-evolutionary knowledge graph, dynamically generate a graph-based task execution plan through goal planning logic.

[0014] 102. Based on the graph-based task execution plan, determine at least one agent to be invoked, and dynamically assemble execution instructions containing relevant historical decisions and domain context from the co-evolutionary knowledge graph for the at least one agent to drive the agent to execute the task.

[0015] 103. Obtain the structured execution result returned by at least one agent, evaluate the performance and verify the knowledge consistency of the structured execution result according to the preset evaluation rules, obtain the evaluation and verification result, and integrate the decision link formed in the execution process of this task into the co-evolutionary knowledge graph in the form of nodes and relationships based on the evaluation and verification result.

[0016] 104. Based on the new content and structural relationships included in the co-evolutionary knowledge graph after fusion, the planning logic of the target is optimized through feedback to improve the generation of subsequent graph-based task execution plans.

[0017] For ease of understanding, the following explains some key terms in this embodiment: A co-evolutionary knowledge graph is a dynamically evolving knowledge base that stores, in graph form, the domain knowledge, agent capabilities, historical decision paths, performance data, and collaborative relationships among agents accumulated by multiple agents during task execution. This graph can be continuously updated and optimized as tasks are executed and results are fed back, supporting agent decision-making and planning.

[0018] The graph state difference refers to the gap between the target graph state expected by the user's task input and the current actual state of the co-evolutionary knowledge graph. This difference is identified by comparing the nodes, relationships, and attributes of the two graph states to clarify the knowledge or state gaps that need to be filled during task execution.

[0019] Historical performance data of agents refers to the performance data of each agent in past task execution recorded in the co-evolutionary knowledge graph, including but not limited to execution time, resource consumption, task success rate, result quality, and collaborative efficiency with other agents. This data is used to evaluate the capabilities and reliability of agents and to guide task planning and agent selection.

[0020] Goal planning logic refers to a set of reasoning mechanisms or algorithms used to dynamically generate graph-based task execution plans based on graph state differences and historical performance data of agents. This logic can combine historical experience with the current environment to formulate a path to achieve the target state.

[0021] A graph-based task execution plan refers to a task execution flow represented in the form of a graph structure, which includes a series of task nodes to be executed, agent invocation nodes, and the logical dependencies between them. The plan specifies in detail the task decomposition, agent selection, execution order, and data flow.

[0022] An intelligent agent is a software or hardware entity that possesses specific capabilities in multi-agent applications, is able to autonomously perform tasks, and interact with the environment or other intelligent agents.

[0023] An execution instruction is a specific command or data packet dynamically assembled for a particular intelligent agent to guide it in performing a task. This instruction typically includes relevant historical decision information, domain context knowledge, and task semantics to ensure the intelligent agent can accurately and efficiently complete the specified operation.

[0024] Structured execution results refer to the result data returned by the agent after completing a task, conforming to a predefined data format. This result typically includes the task execution status, output content, key metrics, etc., facilitating subsequent evaluation and processing.

[0025] Evaluation rules refer to the pre-defined standards and computational methods used to measure the performance and knowledge consistency of an agent's execution results. These rules define how to extract features from structured execution results, how to perform quantitative evaluation, and how to determine knowledge conflicts.

[0026] Knowledge consistency verification refers to the process of logically comparing the core conclusions in the structured execution results returned by the agent with the existing relevant knowledge in the co-evolutionary knowledge graph. Its purpose is to discover and resolve potential knowledge conflicts, ensuring the internal consistency and accuracy of the knowledge graph.

[0027] The evaluation and verification results refer to the comprehensive feedback obtained after evaluating the performance and verifying the knowledge consistency of the agent's structured execution results. This result includes performance scores, knowledge conflict status, and arbitration conclusions, and is used to guide the integration of decision-making processes and the optimization of goal-planning logic.

[0028] A decision-making chain refers to the key decision-making steps, agent calls, and causal relationships involved in the entire task execution process, from user task input to the output of the agent. This chain is recorded in the co-evolutionary knowledge graph in the form of nodes and relationships, serving as experience for learning and evolution.

[0029] Feedback-based optimization refers to the process of iteratively improving the goal planning logic based on newly added decision-making links, performance data, and structural relationships in the co-evolutionary knowledge graph. Its purpose is to enable the goal planning logic to learn from historical experience and continuously optimize the quality of subsequent task execution plans.

[0030] This embodiment provides a management method for multi-agent applications that integrates graph orchestration and expert capabilities. It receives user task input and, based on the current state of the co-evolutionary knowledge graph, determines the graph state difference between the target graph state corresponding to the user task input and the current state. For example, if the user inputs "generate a summary of Company A's latest financial report," the method analyzes the task and transforms it into a desired graph state, i.e., the existence of a node in the co-evolutionary knowledge graph that reads "Summary of Company A's Latest Financial Report." Simultaneously, it acquires the current state of the co-evolutionary knowledge graph; for example, the current graph might only contain historical financial report information for Company A, without the latest summary. By comparing the target graph state with the current state, the method identifies the graph state difference, indicating that a summary of Company A's latest financial report needs to be generated.

[0031] By leveraging the state differences in this knowledge graph and combining it with historical agent performance data recorded in the co-evolutionary knowledge graph, a graph-based task execution plan is dynamically generated through goal-oriented programming logic. For example, the goal-oriented programming logic can search for agents related to the "summary generation" task based on a pre-defined rule base and arrange these agents in a fixed order to form a preliminary task flow. Alternatively, the goal-oriented programming logic can explore possible task paths in the graph based on a heuristic search algorithm, assign an estimated cost to each path, and then select the path with the lowest cost as the task execution plan. During plan generation, historical agent performance data can be used for initial agent screening, for example, prioritizing agents that perform well in similar tasks. Thus, a graph-based task execution plan comprising a "data acquisition agent - text analysis agent - summary generation agent" is constructed.

[0032] Furthermore, after the graph-based task execution plan is generated, the agents to be invoked are determined based on this plan. For example, if the plan includes a "data acquisition agent," that agent is identified as the agent to be invoked. Execution instructions are dynamically assembled for each agent to be invoked. Specifically, historical decision records related to the current task can be retrieved from the co-evolutionary knowledge graph, such as problems and solutions encountered in the past when collecting financial report data from Company A. Simultaneously, task-related domain context information is extracted, such as Company A's industry background and specific format requirements for financial report data. This historical decision and domain context information is structured and integrated into the execution instructions, which are then sent to the corresponding agent. For example, after receiving the instructions, the data acquisition agent will begin executing the data acquisition task based on the source of the financial report data, the acquisition method, and historical acquisition experience contained in the instructions.

[0033] Furthermore, after completing a task, the agent returns structured execution results. For example, a data acquisition agent might return the original financial statement data file, a text analysis agent might return a key information extraction report, and a summary generation agent might return a financial statement summary text. After obtaining these results, their effectiveness is evaluated and knowledge consistency is checked according to preset evaluation rules. For example, the evaluation rules can check whether the results meet preset format requirements, or score the quality of the results through manual review. Knowledge consistency verification can involve performing simple keyword matching between the new knowledge generated by the agent and existing knowledge in the knowledge graph to identify potential conflicts.

[0034] After obtaining the evaluation and verification results, the decision-making chain formed during the task execution process will be integrated into the co-evolutionary knowledge graph in the form of nodes and relationships. For example, information such as user tasks, generated plans, invoked agents, agent execution results, and evaluation and verification results can be added to the graph as a series of interconnected nodes and edges. For instance, a "task node" can be created, connected to the "plan node," then to the "agent invocation node," and finally to the "result node." Performance scores and knowledge conflict information from the evaluation and verification results can be attached as attributes to these nodes or edges.

[0035] After decision-making links are integrated into the co-evolutionary knowledge graph, the graph will contain new content and structural relationships. Based on these new contents and relationships, the goal planning logic will be dynamically optimized. For example, the newly added decision-making links in the graph can be scanned periodically to identify which tasks were successful and which failed. For successful tasks, the decision-making link can be stored as a success case for direct reference in subsequent planning. For failed tasks, the agents or decision steps that led to the failure can be recorded, and these agents or steps can be avoided in subsequent planning. In this way, the goal planning logic can learn from historical experience and continuously improve its ability to generate graph-based task execution plans. For example, if an agent performs poorly in multiple tasks, its historical performance data will be updated, resulting in it being selected less frequently in subsequent planning.

[0036] This method avoids the rigidity of traditional static orchestration by dynamically generating graph-based task execution plans and incorporating historical performance data of agents. By dynamically assembling execution instructions that include historical decisions and domain context for agents, it ensures the reliability and controllability of task execution, solving the problem of difficulty in guaranteeing task goal consistency in decentralized evolutionary paradigms. Furthermore, by integrating the decision-making chain of the task execution process into a co-evolutionary knowledge graph and performing feedback-based optimization of the goal planning logic, it achieves structured accumulation and reuse of decision-making experience, enabling multiple agents to continuously learn and evolve. This overcomes the existing technical challenge of simultaneously achieving globally controllable orchestration and autonomous continuous optimization.

[0037] This application further proposes a management method for multi-agent applications that integrates graph orchestration and expert capabilities, see [link to relevant documentation]. Figure 2 Taking the server as the executing entity as an example, the steps for dynamically generating a graph-based task execution plan through goal planning logic based on graph state differences and historical performance data of agents recorded in the graph include:

[0038] 201. Based on graph state differences, retrieve historical task execution subgraphs and successful strategy patterns related to eliminating graph state differences from the co-evolutionary knowledge graph.

[0039] 202. Using historical task execution subgraphs and successful strategy patterns as references, and combining historical performance data of the agent, reasoning is performed to generate one or more candidate task flows.

[0040] 203. For one or more candidate task flows, evaluate them based on predefined optimization objectives, and select a graph-based task execution plan based on the evaluation results.

[0041] Specifically, in the step of retrieving historical task execution subgraphs and successful strategy patterns related to eliminating graph state differences from the co-evolutionary knowledge graph based on graph state differences, the core lies in using the historical experience accumulated in the co-evolutionary knowledge graph to guide the planning of the current task. This step aims to efficiently identify and extract past successful practices related to the current task objective (i.e., eliminating graph state differences).

[0042] In the step of generating one or more candidate task flows by inferring from historical task execution subgraphs and successful strategy patterns in conjunction with historical performance data of agents, the aim is to transform the identified historical success patterns into specific, executable task sequences, taking into account the actual capabilities and past performance of available agents.

[0043] In the steps of evaluating one or more candidate task flows based on predefined optimization objectives and selecting a graph-based task execution plan based on the evaluation results, its role is to select the optimal solution that best meets the system performance requirements and priority settings from multiple potential task execution schemes.

[0044] By employing the aforementioned technical solution, and retrieving historical task execution subgraphs and successful strategy patterns from the co-evolutionary knowledge graph based on graph state differences, it is possible to locate historical experiences highly relevant to the current task objective, avoiding blind searches and improving the efficiency and relevance of historical experience utilization. Simultaneously, this application can generate and optimize candidate task flows. Using these historical patterns as a reference and combining them with historical agent performance data for reasoning, multiple candidate task flows can be generated. This multi-solution generation mechanism not only considers historical successful paths but also incorporates the actual performance of the agent, making the generated task flows more diverse and adaptable, and reducing the risk of relying on a single solution. Furthermore, this application ensures the reliability and efficiency of the plan. Further, by evaluating these candidate task flows based on predefined optimization objectives and selecting the optimal graph-based task execution plan based on the evaluation results, it ensures that the final selected plan achieves optimal performance in terms of execution efficiency, success rate, resource consumption, or knowledge conflict risk, thereby improving the reliability and overall efficiency of task execution. Based on the aforementioned multi-agent management method, this implementation refinement makes the core step of "dynamically generating graph-based task execution plans" more intelligent and efficient. It transforms the valuable historical experience and agent performance data accumulated in the co-evolutionary knowledge graph from passive storage into a basis for proactive planning, enhancing adaptability and decision-making quality when facing new tasks. This intelligent planning based on historical experience not only accelerates the generation process of task execution plans, but more importantly, through multi-scheme evaluation and optimization, it ensures the robustness and optimality of the plan, thereby enabling the entire multi-agent system to become "smarter with use" and continuously evolve.

[0045] This application further proposes a method for retrieving historical task execution subgraphs and successful strategy patterns related to eliminating state differences in a co-evolutionary knowledge graph, based on the graph state differences. This includes: parsing the graph state differences to obtain at least one target entity node and at least one target relationship type involved in the graph state differences; using the at least one target entity node as a query anchor, searching for past task execution records containing the at least one target entity node and the at least one target relationship type in the decision and evolution subgraph of the co-evolutionary knowledge graph; extracting task execution path segments centered on the at least one target entity node from the found past task execution records, using these segments as the historical task execution subgraph, and extracting successful strategy nodes from these task execution path segments as the successful strategy patterns.

[0046] Specifically, the graph state differences are analyzed to obtain at least one target entity node and at least one target relation type involved in the graph state differences. This step aims to concretize the abstract graph state differences into actionable, concrete elements at the knowledge graph level, namely target entity nodes and target relation types. This is the foundation for accurate retrieval of historical data. Through analysis, it is possible to clarify which entities and what relationships exist between these entities in the core problem that the current task needs to solve, thus providing precise query conditions for subsequent retrieval. For example, semantic analysis of the text descriptions representing graph state differences can be performed using Natural Language Processing (NLP) techniques to identify noun phrases as potential entities and verbs or verb phrases as potential relations. Alternatively, this can be achieved through predefined pattern matching rules or ontology-based mapping mechanisms. A difference pattern library is maintained, and when a certain graph state difference is detected, it is matched with a preset pattern in the pattern library to automatically extract the corresponding target entity node type and target relation type.

[0047] Based on this, using at least one target entity node as the query anchor, the decision and evolution subgraph of the co-evolutionary knowledge graph is used to search for past task execution records containing at least one target entity node and at least one target relation type. This step utilizes the parsed specific target to perform targeted historical data retrieval in the knowledge graph. Using target entity nodes as query anchors means expanding the search outward from these entities to find historical task execution records related to these entities and specific relation types. This ensures the contextual relevance of the retrieval results and avoids blind global searches. For example, a path query language (such as Cypher or Gremlin) from a graph database can be used for pattern matching to construct a query statement that starts from a specified entity node and searches along a specific relation type to find paths connecting to other nodes; these paths represent past task execution records. Alternatively, an index-based retrieval method can be used to build an inverted index or graph index for entities, relations, and task execution records in the knowledge graph. When a query anchor and relation type are received, the index can be used to quickly locate the relevant task execution records.

[0048] Furthermore, from the retrieved past task execution records, task execution path segments centered on at least one target entity node are extracted as the historical task execution subgraph, and successful policy nodes within these task execution path segments are extracted as the successful policy patterns. This step refines and structures the retrieved original historical records, extracting reusable knowledge. It trims the complete task execution record into path segments most relevant to the current goal and further identifies the successful parts, forming a historical task execution subgraph and successful policy patterns that can be used for reference. This provides a high-quality reference for subsequently generating candidate task flows. For example, graph traversal algorithms (such as Depth-First Search (DFS) or Breadth-First Search (BFS)) can be used to start from the query anchor entity, follow the causal relationship edges in the task execution record, limit the traversal depth or range, and extract the smallest subgraph containing the target entity node and target relationship type as the task execution path segment. Simultaneously, during the traversal, the metadata of each node or edge is examined to identify policy nodes marked as successful. Alternatively, a series of graph patterns representing task execution path segments and success strategy patterns can be defined using a preset pattern recognition algorithm. Then, the found past task execution records can be matched with these patterns to automatically extract subgraphs and strategy nodes that meet the conditions.

[0049] By employing the aforementioned technical solution, and through refined analysis of graph state differences, combined with anchor-based queries and result refinement, the high relevance and effectiveness of the acquired historical task execution subgraphs and successful strategy patterns with the current task objectives are ensured. This makes the subsequent candidate task flows generated based on these historical experiences more accurate and reliable, improving the quality and efficiency of graph-based task execution plan generation, thereby optimizing the management effect of multi-agent applications.

[0050] This application further proposes a method to generate one or more candidate task flows by referencing the historical task execution subgraph and successful strategy patterns, combined with the agent's historical performance data. This includes: combining the historical task execution subgraph with the successful strategy patterns to obtain an initial task execution path template; matching one or more candidate agents with satisfactory performance for each task node in the initial task execution path template based on the agent's historical performance data; and evolving the initial task execution path template based on the collaborative records and data interface constraints between the one or more candidate agents to obtain multiple candidate task flows with different agent combinations and execution orders.

[0051] Specifically, the initial task execution path template is obtained by combining historical task execution subgraphs with successful policy patterns. The historical task execution subgraph refers to fragments of past task execution paths retrieved from the co-evolutionary knowledge graph that are related to eliminating graph state differences; it represents a sequence of specific steps for solving similar problems in the past. The successful policy pattern refers to policy nodes marked as successful extracted from the historical task execution subgraph; it abstracts a problem-solving paradigm or decision-making process in a specific context. Combination refers to fusing the historical task execution subgraph and the successful policy pattern to construct a preliminary task execution framework. For example, a graph merging algorithm can be used to embed successful policy patterns as critical paths or substructures into the historical task execution subgraph, forming a more complete and instructive initial task execution path template. Alternatively, successful policy patterns can be used as a skeleton, and specific execution details from the historical task execution subgraph can be filled into the skeleton to generate a template containing successful experiences and specific execution steps. The initial task execution path template is a preliminary task execution flowchart combining historical execution experience and successful policies; it provides the basic structure for subsequent agent matching and task flow evolution.

[0052] Based on this, and using historical performance data of the agents, one or more candidate agents with satisfactory performance are matched for each task node in the initial task execution path template. Historical performance data refers to performance indicators recorded in the co-evolutionary knowledge graph regarding each agent's performance in executing different types of tasks, such as task completion time, accuracy, resource consumption, and success rate. This data reflects the agent's actual working ability and reliability. A task node refers to a unit in the initial task execution path template representing a specific task or operation. Matching refers to selecting agents that are capable of performing the task and have good performance based on the specific requirements of the task node and the agent's historical performance data. For example, a performance threshold can be set, selecting only agents with a historical success rate higher than that threshold. Alternatively, agents with corresponding capabilities can be retrieved from the agent capability library based on the type of task node and required skills, and then sorted and optimized using their historical performance data to ensure that the matched agents are "performance-compliant." A performance-compliant candidate agent is one that, after matching and screening, is considered capable and has a good historical performance in executing a specific task node.

[0053] Furthermore, based on the collaboration records and data interface constraints among one or more candidate agents, the initial task execution path template is evolved to obtain multiple candidate task flows with different agent combinations and execution orders. Here, collaboration records refer to data stored in the co-evolutionary knowledge graph regarding the historical collaboration between different agents, including their data exchange patterns, communication protocols, collaboration efficiency, and success or failure cases. Data interface constraints refer to the formats, types, protocols, and other specifications that agents must follow when inputting and outputting data, ensuring that data can be transmitted and processed correctly. Evolution refers to generating multiple possible agent combinations and execution orders based on the initial task execution path template, considering the collaboration records and data interface constraints among agents. For example, a heuristic search algorithm can be used to explore different agent combinations in the candidate agent set, evaluate their collaboration efficiency based on the collaboration records, and check the data interface constraints to ensure feasibility, thereby generating multiple candidate task flows with different agent configurations and execution processes. Alternatively, a rule-based inference engine can be used to transform and extend the initial template according to predefined collaboration rules and interface compatibility rules to generate diverse task flow variants. Agent composition and execution order refer to which agents are selected to perform tasks in a specific task flow, and in what order they cooperate. Candidate task flow refers to a complete task execution plan that has evolved but has not yet undergone final evaluation and selection, and includes specific agent compositions and execution orders.

[0054] By combining historical task execution subgraphs with successful strategy patterns using the aforementioned technical solution, past successful experiences can be fully utilized to provide a validated and reliable initial framework for task flow construction, avoiding the blindness of starting from scratch and ensuring the rationality of subsequent task flows. Based on this, candidate agents with satisfactory performance are matched to each task node using historical agent performance data, ensuring that each stage of the task is executed by an agent with corresponding capabilities and good performance. This improves the quality and efficiency of task execution and avoids bottlenecks caused by insufficient agent capabilities or poor performance. Furthermore, by considering the collaborative records and data interface constraints between agents to evolve the initial task execution path template, the generated multiple candidate task flows not only have greater diversity in agent selection but also better conform to the feasibility and efficiency of actual operation in terms of agent collaboration methods and data flow. This allows selection from multiple optimized solutions to generate a more robust, efficient, and realistically suited graph-based task execution plan, improving the adaptability and reliability of multi-agent systems in complex task scenarios.

[0055] This application further proposes an evolution of the initial task execution path template based on the collaborative records and data interface constraints between one or more candidate agents, resulting in multiple initial candidate task flows with different agent combinations and execution orders. Specifically, this includes: selecting one agent from each of the multiple candidate agents matched to each task node of the initial task execution path template to obtain a first agent combination sequence; determining the historical collaborative efficiency score between adjacent agents in the first agent combination sequence based on the collaborative record, and sorting the execution order of the agents in the first agent combination sequence according to the historical collaborative efficiency score; verifying the input-output compatibility between adjacent agents in the sorted first agent combination sequence based on the data interface constraints, and instantiating the verified agent combinations and execution orders into a candidate task flow; repeating the steps of determination, sorting, verification, and instantiation to obtain multiple different candidate task flows.

[0056] Specifically, from the multiple candidate agents matched to each task node of the initial task execution path template, one agent is selected for each task node, resulting in a first agent combination sequence. This step aims to provide a basic combination framework for subsequent optimization, avoiding incomplete combinations caused by random or disordered selection. In practice, various strategies can be used to select agents. For example, for each task node, an agent can be selected from its matched candidate agents based on preset priority rules (such as the agent's historical success rate, resource consumption, or specific capability tags). Alternatively, random sampling can be used to randomly select an agent from the candidate agent set corresponding to each task node to generate diverse initial combination sequences.

[0057] Based on this, and using the collaboration record, historical collaboration efficiency scores are determined between adjacent agents in the first agent combination sequence, and the execution order of the agents in the first agent combination sequence is sorted according to these historical collaboration efficiency scores. This step utilizes historical collaboration data to evaluate the collaborative effectiveness between agents, thereby prioritizing efficient combinations and improving the overall execution efficiency of the task flow. The collaboration record can store detailed data on past collaborations between agents, such as data transmission latency, interface call success rate, and average time to complete tasks jointly. These records can be analyzed to calculate the collaboration efficiency scores between adjacent agent pairs; for example, by statistically analyzing the average processing time or error rate of a specific agent pair when processing specific types of data to quantify its collaboration efficiency. Then, sorting algorithms (such as topological sorting or weight-based sorting) can be used to adjust the execution order of agents in the sequence to maximize overall collaboration efficiency.

[0058] Simultaneously, based on this data interface constraint, the input-output compatibility between adjacent agents in the sorted first agent combination sequence is verified. The verified agent combinations and execution order are then instantiated into a candidate task flow. This step, by verifying the matching of the data interface, ensures seamless data transfer between agents, prevents execution interruptions or errors, and enhances the feasibility of the task flow. The data interface constraint can include specifications for data format, data type, data range, and data semantics. The output data patterns of adjacent agents can be compared with their input data patterns; for example, by checking whether the output data structure of the upstream agent is compatible with the input data structure of the downstream agent, or whether a usable data converter exists for adaptation. Only when the input-output compatibility of all adjacent agent pairs passes the verification will the agent combination and execution order be instantiated into an initial candidate task flow.

[0059] To increase the optimization space and selection flexibility, this method repeatedly performs the steps of determination, sorting, verification, and instantiation to obtain multiple different candidate task flows. By iteratively generating diverse options, a broader solution space can be explored. For example, different selection strategies (such as rotational selection or selection based on different heuristics) can be used in the "agent selection" step, or different optimization objectives (such as prioritizing speed or cost) can be considered in the "sorting" step to generate multiple candidate task flows with different characteristics. These diverse candidate task flows provide rich alternatives for subsequent evaluation and selection, thereby improving adaptability and reliability.

[0060] Through the above technical solution, this method can systematically construct diverse agent combination sequences from multiple candidate agents and optimize these sequences by sorting them using historical collaboration records, ensuring efficient collaboration between agents. Simultaneously, rigorous data interface compatibility checks prevent execution interruptions or errors caused by data format incompatibility, improving the feasibility and reliability of the task flow. Repeating these steps generates multiple preliminary optimized and validated candidate task flows, providing rich and high-quality options for subsequent evaluation and selection. This improves the efficiency of task execution plan generation and the final task success rate, resolving potential issues of low agent collaboration efficiency and data interface incompatibility during task flow generation.

[0061] This application further proposes evaluating one or more candidate task flows based on predefined optimization objectives, and selecting a graph-based task execution plan based on the evaluation results. Specifically, this includes: performing a matching degree analysis between each candidate task flow and successful strategy patterns in the co-evolutionary knowledge graph to obtain the pattern fit degree for each candidate task flow; determining the potential knowledge conflict risk level of each candidate task flow on the co-evolutionary knowledge graph during execution based on historical agent performance data; and making a multi-objective trade-off decision between pattern fit degree and knowledge conflict risk level based on predefined optimization objectives, and selecting a graph-based task execution plan based on the decision results.

[0062] The analysis involves matching each candidate task flow with successful strategy patterns in the co-evolutionary knowledge graph to quantify the similarity between the candidate task flow and historical successful experiences. This ensures that newly generated task plans can inherit and reuse validated paths and methods, thereby improving the success rate and efficiency of task execution. Specifically, this can be achieved through graph structure similarity algorithms, such as calculating the graph edit distance between the graph structure of the candidate task flow and the graph structure of the successful strategy pattern, or extracting feature vectors based on node type, edge type, and topology, and then calculating the cosine similarity between the vectors. Alternatively, semantic matching methods can be used, such as mapping task nodes and agent nodes in the candidate task flow, as well as the relationships between them, to semantic embedding vectors, and then calculating the similarity between these vectors and the corresponding semantic embedding vectors of the successful strategy pattern to assess their semantic fit. Successful strategy patterns refer to task execution path segments or decision sequences in the co-evolutionary knowledge graph that have been validated and marked as successful in historical task execution, possessing specific structural and semantic features. These patterns represent a summary of experiences in efficient collaboration and problem-solving among agents in specific task scenarios.

[0063] Based on historical performance data of agents, the risk level of knowledge conflict that each candidate task flow may generate with the co-evolving knowledge graph during execution is determined. The knowledge conflict risk level is a quantitative assessment of the likelihood and severity of contradictions, inconsistencies, or the introduction of erroneous information between the execution results or decision logic of a candidate task flow and existing knowledge (including facts, rules, historical decisions, etc.) in the co-evolving knowledge graph. Its purpose is to predict and avoid potential knowledge inconsistencies, maintaining the accuracy and reliability of the knowledge graph. Specifically, by analyzing indicators such as error rate, failure cases, and knowledge correction times recorded in the historical performance data of agents, combined with the agents involved in the candidate task flow and their execution steps, the probability of knowledge conflict that the task flow may introduce can be predicted. For example, if an agent frequently makes errors when processing a specific type of data, the knowledge conflict risk level of related task flows involving that agent will increase accordingly. Alternatively, evaluation can be conducted through simulated execution or expert rules. For example, a simulation environment can be constructed to virtually execute the key steps of the candidate task flow and compare them with preset rules in the knowledge graph to identify potential points of conflict. Alternatively, based on a predefined set of knowledge conflict rules, a static analysis can be performed on the expected input and output of candidate task flows to determine if there are any incompatibilities with the existing knowledge graph. Historical performance data of the agents includes records of each agent's performance in past task executions, such as task completion time, resource consumption, accuracy of output results, error rate, success rate, and records of consistency between its output and existing knowledge in the knowledge graph. This data is crucial for assessing the reliability of agents and predicting their potential risks.

[0064] Based on predefined optimization objectives, a multi-objective trade-off decision is made between pattern fit and knowledge conflict risk level, and a graph-based task execution plan is selected based on the decision results. The predefined optimization objectives refer to multiple performance indicators or strategy preferences pursued when generating the graph-based task execution plan. These objectives can be competitive, such as maximizing pattern fit (pursuing stability) versus minimizing knowledge conflict risk (pursuing accuracy), or others such as minimizing execution time or cost. Their role is to provide clear guiding principles and evaluation criteria for task plan selection. Specifically, multi-objective trade-offs can be performed by setting weight coefficients. For example, a weight W1 can be assigned to pattern fit, and a weight W2 to knowledge conflict risk level. Then, the comprehensive score for each candidate task flow is calculated as W1 × pattern fit - W2 × knowledge conflict risk level (or its reciprocal), and the task flow with the highest comprehensive score is selected. Alternatively, the Pareto optimization method can be used to identify all non-dominated solutions (i.e., solutions that cannot improve one objective without sacrificing another), and then, based on user preferences or preset priority rules, the final graph-based task execution plan is selected from the Pareto front. Multi-objective trade-off decision-making refers to the process of finding a solution that is optimal overall or satisfies specific preferences when multiple interrelated or potentially conflicting optimization objectives exist, through a certain strategy or algorithm that comprehensively considers all objectives. Its purpose is to ensure that the selected task plan not only performs well in a single dimension, but also achieves balance and optimization across multiple key dimensions.

[0065] The above technical solution analyzes the matching degree between each candidate task flow and successful strategy patterns in the co-evolutionary knowledge graph, ensuring that the plan inherits historical successful experience and improves execution reliability and efficiency. Based on the agent's historical performance data, the knowledge conflict risk level is determined, and potential conflicts are predicted using historical data to avoid inconsistencies during execution. Multi-objective trade-off decisions are made based on predefined optimization objectives, comprehensively considering matching degree and risk to achieve balanced optimization. Finally, a graph-based task execution plan is selected based on the decision results, ensuring that the plan is optimal across multiple dimensions and improving overall performance. This evaluation method enables more intelligent selection of task execution plans, not only reusing historical successful experience but also avoiding potential knowledge conflicts, thereby improving the stability and reliability of multi-agent applications and enabling them to exhibit stronger adaptability and better execution performance in complex dynamic environments.

[0066] This application further proposes a multi-objective trade-off decision based on predefined optimization objectives, balancing pattern fit and knowledge conflict risk level, and selecting a graph-based task execution plan based on the decision results. The process includes: setting optimization directions and trade-off thresholds for pattern fit and knowledge conflict risk level based on predefined optimization objectives; selecting a set of feasible task flows from one or more candidate task flows that simultaneously meet the lower limit requirement for pattern fit and the upper limit requirement for knowledge conflict risk level based on the optimization directions and trade-off thresholds; determining a comprehensive trade-off index for each feasible task flow in the set of feasible task flows, considering both pattern fit and knowledge conflict risk level; and selecting the feasible task flow with the optimal comprehensive trade-off index from the set of feasible task flows as the graph-based task execution plan.

[0067] Specifically, when setting the optimization direction and trade-off thresholds, the predefined optimization objective can explicitly specify that pattern fit should be maximized, while the knowledge conflict risk level should be minimized. For example, the optimization direction for pattern fit can be set to "maximize" and the optimization direction for knowledge conflict risk level can be set to "minimize" through the configuration interface or automatically inferred based on task type. Meanwhile, the trade-off thresholds can be set as hard constraints or soft weights. For example, the pattern fit can be set to be higher than a certain percentage (e.g., 80%), and the knowledge conflict risk level can be set to be lower than a certain preset level (e.g., "medium"), as a hard threshold. Alternatively, a higher weight can be assigned to pattern fit (e.g., 0.7), and a lower weight can be assigned to knowledge conflict risk level (e.g., 0.3), with a weighted summation for the trade-off.

[0068] When filtering the set of feasible task flows, one or more candidate task flows are traversed. For each candidate task flow, its pattern fit is first checked to see if it meets a preset lower limit requirement, for example, if it is higher than 80%. Its knowledge conflict risk level is then checked to see if it is lower than a preset upper limit requirement, for example, if it is lower than "medium" risk. Only when a candidate task flow meets both conditions is it included in the set of feasible task flows. This filtering process can be implemented using a database query filter, combining the two conditions through logical AND operations to quickly eliminate candidate solutions that do not meet the basic requirements.

[0069] When determining the comprehensive performance index, for each feasible task flow in the feasible task flow set, it is necessary to quantify its overall performance in two dimensions: pattern fit and knowledge conflict risk level. One approach is to use a weighted summation method, multiplying the pattern fit score and the knowledge conflict risk level score (which may require normalization and reverse processing depending on the optimization direction, e.g., converting the risk level into a risk aversion score) by their respective weights, and then summing them to obtain the comprehensive index. For example, the comprehensive index can be calculated as: W1 × pattern fit score + W2 × (1 - knowledge conflict risk level score), where W1 and W2 are preset weights. Another approach is to use a multi-attribute decision method, such as TOPSIS (Top-Order Solution Approximation), which calculates the comprehensive performance score of each feasible task flow by constructing a decision matrix and evaluation function, thereby more comprehensively reflecting its advantages and disadvantages.

[0070] When selecting the optimal feasible task flow, the comprehensive trade-off metrics of all task flows in the feasible task flow set are compared. For example, if a higher comprehensive trade-off metric indicates better performance, the task flow with the highest comprehensive trade-off metric is selected as the final graph-based task execution plan. If multiple task flows have the same optimal comprehensive trade-off metric, secondary optimization objectives (e.g., shortest execution time, least resource consumption) can be introduced for further filtering, or selection can be based on preset priority rules.

[0071] Through the above technical solution, this application addresses the challenge of simultaneously balancing pattern fit and knowledge conflict risk levels when evaluating candidate task flows, thus avoiding biased or risky decision-making. By setting clear optimization directions and trade-off thresholds, it provides clear guidance and quantitative standards for multi-objective decision-making. A screening mechanism quickly eliminates solutions that do not meet basic requirements, improving decision-making efficiency and security. The calculation of comprehensive trade-off indicators integrates multiple interrelated factors into a unified evaluation standard, quantifying the overall performance of each solution. Finally, the optimal solution is selected, ensuring that in complex multi-objective scenarios, the chosen graph-based task execution plan maximizes its fit with historically successful patterns while controlling potential knowledge conflict risks. This refined decision-making mechanism not only considers the reuse of historical experience when generating task execution plans but also proactively avoids potential knowledge system disruption, thereby promoting the stability and continuous optimization of the co-evolutionary knowledge graph and enhancing the reliability and intelligence of the entire management method.

[0072] This application further proposes a method based on a graph-based task execution plan, which identifies at least one agent to be invoked and dynamically assembles execution instructions for that agent from the co-evolutionary knowledge graph, including relevant historical decisions and domain context. See [link to relevant documentation]. Figure 3 Specifically, it includes: 301. Analyze the graph-based task execution plan to obtain the calling nodes of each agent in the graph-based task execution plan and the corresponding task semantics.

[0073] 302. For each agent calling node, determine the context type and relational constraints that need to be retrieved from the co-evolutionary knowledge graph based on the semantics of the task.

[0074] 303. Based on the context type and the association constraint, query and extract relevant historical decision path fragments and domain fact nodes from the co-evolutionary knowledge graph.

[0075] 304. The historical decision path fragment, the fact node of the domain, and the semantics of the task are structurally concatenated to obtain the execution instructions for calling the node for each agent.

[0076] Specifically, in the step of parsing the graph-based task execution plan to obtain each agent calling node and its corresponding task semantics, the core lies in decomposing the complex graph-based task execution plan into discrete units that can be executed by a single agent, and clarifying the goal and input requirements of each unit. One implementation is to traverse the graph structure of the graph-based task execution plan, identifying all nodes marked as "agent calling" types; these nodes are the agent calling nodes. For each agent calling node, its associated metadata is extracted, such as task goal descriptions (e.g., "generate report," "analyze data") and input data patterns (e.g., "requires document ID and analysis dimensions"), and this information is combined to form the agent's task semantics. Another implementation is to utilize graph pattern matching technology to identify predefined agent calling patterns, such as a node containing specific input and output edges, and automatically extract agent calling nodes and their task semantics from these patterns.

[0077] In the step of determining the context types and relational constraints to be retrieved from the co-evolutionary knowledge graph based on the task semantics for each agent calling node, the aim is to precisely define which types of background information need to be obtained from the co-evolutionary knowledge graph and how these information are connected, according to the specific task the agent is about to execute. One implementation is to maintain a semantic mapping rule base, mapping keywords, verbs, or entity types in the task semantics to specific node types (i.e., context types, such as "project document," "user profile," "historical decision record") and relationship types (i.e., relational constraints, such as "belongs to," "participates in," "influences") in the co-evolutionary knowledge graph. For example, if the task semantics are "analyze user behavior," the context types might be determined as "user entity" or "behavior log," and the relational constraints might be "occurred at" or "associated with." Another implementation is to utilize an ontology reasoning mechanism to compare the task semantics with the ontology structure of the co-evolutionary knowledge graph, automatically deriving the most relevant context types and relational constraints through the class relationships and attribute constraints defined in the ontology.

[0078] In the step of querying and extracting relevant historical decision path fragments and domain fact nodes from the co-evolutionary knowledge graph based on the context type and the association constraints, the key lies in efficiently and accurately retrieving information from the vast knowledge graph that has direct guiding significance for the current agent's task execution. One implementation is to construct a graph query statement for the co-evolutionary knowledge graph (e.g., using graph query languages ​​such as SPARQL or Cypher) based on the context type and association constraints determined in the previous step. This query statement precisely specifies the type of nodes to search for, the type of relationships, and the connection patterns between them, thereby extracting subgraph structures that meet the conditions from the knowledge graph as historical decision path fragments and independent domain fact nodes. Another implementation is to use knowledge graph embedding technology to map entities and relationships in the knowledge graph to a low-dimensional vector space. After determining the context type and association constraints, a similarity search can be performed in this vector space to quickly locate and extract the historical decision path fragments and domain fact nodes most relevant to the semantics of the current task.

[0079] In the step of structurally concatenating the historical decision path fragment, the domain fact nodes, and the task semantics to obtain the execution instructions for each agent's calling nodes, the goal is to integrate all relevant information into a unified format that the agent can understand and execute. One implementation approach is to pre-define multiple execution instruction templates (e.g., JSON format, XML format, or function call structures in specific programming languages). Based on the agent's type and task semantics, a suitable template is selected, and the extracted historical decision path fragments (possibly in serialized form), domain fact nodes (possibly in key-value pairs), and the original task semantics are filled into the corresponding fields of the template to form complete structured execution instructions. Another implementation approach is to utilize Natural Language Generation (NLG) technology to convert this structured information into instructions in natural language form, while embedding necessary structured parameters to adapt to the understanding capabilities of certain agents of natural language instructions.

[0080] Through the above technical solution, this application can accurately parse the graph-based task execution plan, identify the agent's calling nodes and their task semantics, laying a solid foundation for subsequent instruction assembly. Simultaneously, by dynamically determining the context type and relational constraints based on task semantics, interference from irrelevant information is avoided, ensuring the targeted and efficient nature of knowledge retrieval. Furthermore, by accurately querying and extracting relevant historical decision path fragments and domain fact nodes, rich historical experience and domain knowledge support are provided to the agent. This information is structured and pieced together to form clear, complete, and executable instructions, improving the accuracy and efficiency of the agent's task execution. This enables multiple agents to obtain more guidance when performing complex tasks, reducing trial-and-error costs, thus solving the problem of potentially inaccurate or inefficient instruction assembly, and further enhancing the "the more you use it, the smarter it becomes" evolutionary capability.

[0081] This application further proposes a method to parse the above-mentioned graph-based task execution plan to obtain each agent's calling node and corresponding task semantics in the graph-based task execution plan, specifically including the following steps: Read the graph structure data of the graph-based task execution plan and extract all nodes from the graph structure data. This step aims to comprehensively obtain the complete information of the graph-based task execution plan, ensuring that subsequent processing can cover all potential agent call points. Specifically, the API interfaces provided by graph databases (e.g., Neo4j, JanusGraph, etc.) can be used to directly read and load the node and edge data of the graph-based task execution plan from the database by executing specific graph query languages (e.g., Cypher query). Alternatively, if the graph-based task execution plan is stored in a file format (e.g., JSON, XML, GraphML, etc.), the file content can be read through a file parser and converted into a graph data structure in memory (e.g., adjacency matrix, adjacency list, or custom graph object model) to extract all nodes.

[0082] Based on the node type attribute of each node, filter out the nodes with the node type of agent call from all nodes as the agent call nodes. This step is a key link in identifying the need for agent intervention in the task execution plan. When specifically implemented, one or more attributes can be preset for each node in the graph data structure, including "node type" (e.g., "task node", "decision node", "agent call node", "data input node", "output node", etc.). All the extracted nodes can be traversed to check whether the "node type" attribute matches the predefined "agent call" type, and all the matching nodes can be collected. Another way is to use the filtering function of the graph query language to directly specify the node type as "agent call" through a conditional statement (e.g., WHERE clause) when reading the graph structure data, so as to extract only the nodes that meet the conditions.

[0083] For each selected agent calling node, the corresponding task objective description and input data pattern are extracted from the node metadata of the graph-based task execution plan, and then combined to form the task semantics. This step aims to build a clear and complete execution context for each agent calling node. Specifically, each agent calling node may directly contain "task objective description" fields (e.g., "generate report," "analyze data," "execute operation") and "input data pattern" fields (e.g., "customer information in JSON format," "CSV file path," "API parameter list") in its metadata. These predefined fields can be read directly. Alternatively, if there are no direct fields in the metadata, an external agent registry or service directory can be queried based on the agent calling node's unique identifier or name. This directory stores the tasks that each agent can perform and their required input / output specifications. After obtaining the task target description and input data pattern, they can be structured, concatenated, encapsulated, or serialized to form a unified "task semantic" object or string, such as a JSON object containing {"target":"Generate Report", "input_schema":{"type":"object", "properties":{"data":{"type":"array", "items":{"type":"number"}}}}}}.

[0084] Through the above technical solution, this application provides a structured parsing method that solves the challenge of accurately identifying agent calling nodes and fully extracting task semantics in complex graph-based task execution plans. By reading graph structure data and extracting all nodes, comprehensive coverage of plan information is ensured, avoiding the problem of missing key nodes due to data omissions, and providing a complete foundation for subsequent screening. Screening is performed based on the node type attributes of each node, using attribute information as a precise filtering standard to distinguish agent calling nodes from other types of nodes, reducing the risk of misjudgment and ensuring that only nodes related to agent calls are selected for processing. For each screened agent calling node, the task target description and input data pattern are extracted from its node metadata, and the two are combined into task semantics. By directly associating node attributes, the integrity and structure of task semantics are guaranteed, greatly facilitating the direct reference of semantics during subsequent instruction assembly. These steps work together to enhance the systematicness and accuracy of the parsing process, thereby improving the reliability of subsequent agent instruction assembly, and ultimately ensuring the accuracy of agent task execution and overall operational efficiency.

[0085] This application further proposes a method for determining the context types and relational constraints to be retrieved from a co-evolutionary knowledge graph based on task semantics. Specifically, this method includes: semantic parsing of the task semantics to extract the task target entities and core operation types; mapping the task target entities to at least one target entity node type in the co-evolutionary knowledge graph, and mapping the core operation types to at least one target relation type in the co-evolutionary knowledge graph; combining at least one target entity node type and at least one target relation type to obtain the context type; and determining the allowed connection path patterns between at least one target entity node type and at least one target relation type in the co-evolutionary knowledge graph as relational constraints.

[0086] Specifically, semantic parsing of task semantics extracts the target entities and core operation types from the task semantics, aiming to identify the core "objects" and "behaviors" of the user-input task description from natural language or structured text. For example, for a task "query hotel prices in Shanghai," the semantic parsing process identifies "Shanghai" and "hotel" as the target entities, while "query...prices" is the core operation type. This process can be achieved in several ways. On the one hand, advanced natural language processing (NLP) techniques can be used, such as Named Entity Recognition (NER) models, to identify specific entities in the task description, and combined with dependency parsing or semantic role labeling (SRL) techniques to accurately identify predicates and their arguments, thereby determining the core operation type. On the other hand, for structured or semi-structured task semantics, a series of task templates and keyword dictionaries can be pre-defined. By matching the task semantics with these templates, entities and operation keywords at predefined locations can be extracted from the matched templates.

[0087] Building upon this, the task target entity is mapped to at least one target entity node type in the co-evolutionary knowledge graph, and the core operation type is mapped to at least one target relation type in the co-evolutionary knowledge graph. The purpose of this step is to transform the general semantic elements extracted in the previous step into specific structured representations understood and used within the co-evolutionary knowledge graph. For example, the task target entity "hotel" is mapped to the predefined HotelEntity node type in the knowledge graph, and the core operation type "query" is mapped to the queryInfo relation type. This mapping can be achieved by maintaining an ontology mapping table or dictionary that explicitly defines the correspondence between general semantics and types within the knowledge graph. Alternatively, an embedded vector similarity matching method can be used to convert the task target entity, core operation type, and entity node types and relation types in the knowledge graph into low-dimensional vector representations, and then complete the mapping by calculating the similarity between these vectors.

[0088] Furthermore, combining at least one target entity node type and at least one target relation type yields a context type. This combination operation clarifies the scope and nature of the context information to be retrieved for this task. For example, if the target entity node type is HotelEntity and the target relation type is queryInfo, the resulting context type might be represented as (HotelEntity, queryInfo), indicating that context information related to a hotel query needs to be retrieved. This context type can be represented as a structured tuple or defined as a small graph schema in a knowledge graph that contains one or more target entity node types and the target relation types connecting them.

[0089] Simultaneously, the allowed connection path patterns between at least one target entity node type and at least one target relation type in the co-evolutionary knowledge graph are defined as association constraints. This constraint further refines the rules for context retrieval, defining the meaningful ways in which these target entity node types and target relation types can be connected within the knowledge graph. For example, it can be stipulated that the path from HotelEntity to LocationEntity must pass through the locatedIn relation and not through other unrelated relations. These constraints can be predefined as a series of allowed graph traversal path rules, stored in the knowledge graph's metadata or a separate rule base. Furthermore, graph pattern matching and verification mechanisms can be used to limit the length of the retrieval path, the specific intermediate node types that must be traversed, etc., to ensure that the retrieved context is not only type-correct but also structurally meaningful.

[0090] Through the above technical solution, this application can accurately extract key elements from task semantics and map them into the structure of a co-evolutionary knowledge graph. Semantic parsing accurately captures the core intent of the task, avoiding biases in initial semantic understanding. Accurately mapping task target entities and core operation types to node types and relationship types in the knowledge graph ensures retrieval compatibility and accuracy. Then, by combining these types to form explicit context types, the retrieval scope is limited, improving retrieval efficiency. By defining relational constraints, the traversal path of the knowledge graph is further standardized, avoiding the retrieval of irrelevant or structurally invalid information. These steps work together to ensure that the retrieved contextual information is highly relevant, accurate, and efficient when dynamically assembling and executing instructions for the agent, thereby improving the accuracy of the agent's instruction execution and the overall efficiency of task execution.

[0091] This application further proposes a method for evaluating the effectiveness and verifying the knowledge consistency of structured execution results based on preset evaluation rules, and obtaining the evaluation and verification results. See [link to relevant documentation]. Figure 4 The specific steps include: 401. Extract execution efficiency features and result quality features from structured execution results.

[0092] 402. Compare the core conclusions in the structured execution results with the existing conclusion nodes associated with them in the co-evolutionary knowledge graph for logical consistency.

[0093] 403. Based on the preset evaluation rules, the comparison results of execution efficiency characteristics, result quality characteristics, and logical consistency comparison are comprehensively calculated to obtain a multi-dimensional evaluation vector.

[0094] 404. When a conflict is found during logical consistency comparison, the conflict is arbitrated based on the preset conflict resolution rules.

[0095] 405. Combine the multidimensional evaluation vector with the conflict resolution conclusion after arbitration to form the evaluation and verification result.

[0096] Specifically, when extracting execution efficiency and result quality features from structured execution results, execution efficiency features aim to indicate the time, computing resources, and number of API calls consumed by the agent to complete the task. For example, this can be obtained by recording the time taken from receiving an instruction to returning a result (e.g., millisecond-level timestamp difference) and the amount of CPU and memory resources consumed during execution. Alternatively, it can be measured by statistically analyzing the number of external services or internal modules called by the agent during task execution and the average response time of these calls. Result quality features aim to indicate the accuracy, completeness, relevance, and format conformity of the agent's output. For example, the accuracy and relevance of the results can be evaluated through predefined keyword matching, semantic similarity analysis, or comparison with standard answers. Alternatively, it can be evaluated by checking the completeness of the result data structure, field fill rate, and whether it conforms to predefined output format specifications.

[0097] When comparing the core conclusions of the structured execution results with the associated existing conclusion nodes in the co-evolutionary knowledge graph for logical consistency, the core conclusion refers to the most critical and informationally valuable part of the agent's execution results, usually the final answer or key judgment pointed to by the task objective. For example, natural language processing (NLP) techniques can be used to extract subject-verb-object structures or key entity relationships from the text results returned by the agent as the core conclusion. Alternatively, predefined pattern matching or semantic parsing rules can be used to identify field values ​​representing the final decision or key facts from structured data. Logical consistency comparison aims to compare whether there are contradictions between the new and old conclusions in terms of semantics, facts, or reasoning chains. For example, an ontology-based reasoning engine can be used to map the new and old conclusions to ontological concepts in the knowledge graph, and then reasoning rules can be used to detect whether there are logical conflicts. Alternatively, the semantic similarity between the new and old conclusions can be calculated; if the similarity is below a preset threshold and both are on the same factual dimension, they are marked as potential conflicts.

[0098] When a multidimensional evaluation vector is obtained by comprehensively calculating the comparison results of execution efficiency features, result quality features, and logical consistency based on preset evaluation rules, the preset evaluation rules include the weights of each feature, scoring criteria, thresholds, and comprehensive calculation methods. For example, it can be a rule set based on expert experience, assigning weights to different dimensions. Alternatively, it can be an evaluation model trained on a machine learning model, which learns how to map each feature to a comprehensive score through historical data and can dynamically adjust the weights. The multidimensional evaluation vector is a vector containing multiple values, each representing an evaluation dimension (such as efficiency score, quality score, and consistency score). For example, efficiency features, quality features, and consistency comparison results can be quantified into scores, and then weighted and summed or directly combined into a vector. Alternatively, fuzzy logic or hierarchical analysis can be used to transform qualitative evaluation into quantitative evaluation, and combined with multi-attribute decision-making methods to generate a comprehensive vector.

[0099] When a logical consistency comparison reveals a conflict, the conflict is arbitrated based on pre-defined conflict resolution rules. These rules determine whether to adopt a new conclusion, retain old knowledge, merge existing knowledge, request human intervention, or employ other strategies. For example, arbitration can be based on the priority of knowledge sources, with knowledge from authoritative data sources having higher priority than knowledge generated by ordinary agents. Alternatively, arbitration can be based on the type and severity of the conflict; minor semantic conflicts can be merged or corrected, while serious logical contradictions may require human verification. Arbitration refers to handling the conflict according to rules to arrive at a final decision. For example, pre-defined rules can be executed automatically; if a new conclusion comes from a highly trusted agent and conflicts with old knowledge, the knowledge graph is automatically updated. Alternatively, when automatic arbitration is not possible, the conflict is marked and submitted for human review, with experts making the final judgment.

[0100] The multidimensional evaluation vector and the conflict resolution conclusion after arbitration are combined to form the evaluation verification result. The evaluation verification result includes the agent's overall performance in this task (multidimensional evaluation vector) and the final decision on conflict handling regarding knowledge consistency. For example, it can be a structured JSON object or XML document containing the components of the multidimensional evaluation vector and a field representing the conflict resolution status. Alternatively, it can be a database record storing all evaluation data and arbitration conclusions in different fields for easy subsequent querying and analysis.

[0101] By extracting execution efficiency and result quality features from structured execution results, the above technical solution enables quantitative evaluation of the agent's execution process and output quality, overcoming the limitations of single-dimensional evaluation. By comparing the core conclusions with existing conclusion nodes in the co-evolutionary knowledge graph for logical consistency, potential knowledge conflicts can be identified and located promptly, maintaining the internal consistency of the knowledge graph. Based on preset evaluation rules, various features and comparison results are comprehensively calculated to generate a multi-dimensional evaluation vector, providing a comprehensive and quantitative basis for subsequent decision-making and optimization. When logical conflicts are detected, arbitration is conducted based on preset conflict resolution rules, ensuring that conflicts are handled reasonably and systematically, avoiding the accumulation of erroneous knowledge, and improving the reliability of the knowledge graph. Finally, the multi-dimensional evaluation vector and the arbitration-resolved conflict resolution conclusions are combined to form the evaluation verification result, providing complete and reliable input for subsequent knowledge fusion and feedback-based optimization of goal planning logic, thereby enhancing the multi-agent's "the more it's used, the smarter it becomes" evolutionary ability and the stability of its overall performance.

[0102] This application further proposes a method based on preset evaluation rules to comprehensively calculate the comparison results of execution efficiency features, result quality features, and logical consistency comparisons, resulting in a multi-dimensional evaluation vector. Specifically, this includes: calculating at least two quantitative indicators in the execution efficiency features based on the efficiency dimension weights in the preset evaluation rules to obtain an efficiency dimension score; calculating at least two quantitative indicators in the result quality features based on the quality dimension weights in the preset evaluation rules to obtain a quality dimension score; transforming the logical consistency comparison results according to the consistency dimension processing strategy in the preset evaluation rules to obtain a consistency dimension score; and combining the efficiency dimension score, quality dimension score, and consistency dimension score in a preset dimension order to obtain the multi-dimensional evaluation vector.

[0103] Efficiency dimension weights refer to the relative importance coefficients assigned to different efficiency quantification indicators when evaluating the execution efficiency of an agent. These weights can be pre-set fixed values, such as those determined through expert experience or historical data analysis, or they can be dynamically adjusted parameters, such as those adaptively optimized by machine learning models based on task type or environmental changes. Their purpose is to ensure that the importance of key indicators is highlighted when comprehensively evaluating efficiency, avoiding interference from secondary indicators in the overall evaluation. Execution efficiency characteristics refer to performance indicators such as time and resource consumption exhibited by the agent during task execution. For example, these may include task completion time, computing resource utilization (such as CPU and memory), network bandwidth consumption, and the time required to process a unit of data. These characteristics are the objective basis for measuring the operational efficiency of the agent, reflecting its performance in resource utilization and response speed. Quantification indicators refer to the standards for specific numerical measurement of execution efficiency characteristics or result quality characteristics. For execution efficiency characteristics, quantification indicators may include average task response time, peak memory usage, average CPU utilization, and the number of requests processed per second. For outcome quality features, quantitative metrics can include accuracy, recall, F1 score, semantic similarity score, error rate, and user satisfaction score. These metrics transform abstract features into calculable and comparable numerical values. Calculating the efficiency dimension score involves weighting, averaging, or performing other mathematical operations on the quantitative metrics within the execution efficiency features according to their efficiency dimension weights, resulting in a comprehensive numerical value that reflects the agent's efficiency performance. For example, a weighted average method can be used, summing different efficiency metrics after multiplying them by their corresponding weights. Alternatively, a fuzzy logic-based scoring mechanism can be used to map multiple metrics to a unified efficiency score range. This calculation process aims to integrate multiple discrete efficiency metrics into a unified and comparable efficiency evaluation value.

[0104] Quality dimension weights refer to the relative importance coefficients assigned to different quantitative quality indicators when evaluating the quality of an agent's execution results. Similar to efficiency dimension weights, these weights can be fixed empirical values ​​or dynamically adjusted parameters based on task requirements or domain characteristics. Their role is to ensure that the overall evaluation of result quality accurately reflects the degree of influence of different quality elements on the final result value. Result quality characteristics refer to the attributes of the results output by the agent after completing the task, such as accuracy, completeness, relevance, and usability. For example, these may include the accuracy of output information, the semantic coherence of generated content, the completeness of data processing, and user satisfaction with the results. These characteristics directly reflect the effectiveness and reliability of the agent in completing the task. Calculating the quality dimension score involves weighted summation, averaging, or other mathematical operations on the quantitative indicators in the result quality characteristics according to the quality dimension weights, thereby obtaining a numerical value that comprehensively reflects the agent's result quality performance. For example, the Analytic Hierarchy Process (AHP) can be used to determine the weights of each indicator before comprehensive scoring. Alternatively, a combination of expert scoring and machine learning can be used to quantitatively evaluate result quality. This calculation process aims to integrate multiple discrete quality indicators into a unified and comparable quality assessment value.

[0105] The consistency dimension processing strategy refers to the specific rules and methods for converting logical consistency comparison results into quantifiable scores. For example, a high score can be awarded when the comparison result shows complete consistency. When there is partial conflict, points are deducted according to the severity or scope of the conflict. When there is complete inconsistency, a low score or zero score is awarded. Another strategy is to directly map the similarity percentage of the comparison result to a score based on a similarity algorithm. This strategy ensures that the complex concept of logical consistency can be quantified in a standardized way. The comparison result of logical consistency refers to the judgment on the logical relationship (such as consistency, conflict, partial consistency, irrelevance, etc.) between the core conclusion in the structured execution result of the agent and the associated existing conclusion nodes in the co-evolutionary knowledge graph. This result can be a Boolean value (consistent / inconsistent), an enumerated value (completely consistent, slightly conflicting, severely conflicting), or a similarity score. Converting the consistency dimension score refers to converting the logical consistency comparison result into a numerical score according to the preset consistency dimension processing strategy. For example, if the comparison result is "completely consistent", it is converted to 1.0. If it's a "minor conflict," it's converted to 0.5. If it's a "serious conflict," it's converted to 0.1. Alternatively, if the comparison result is a similarity percentage, that's used directly as the score. This conversion process allows the consistency dimension to be treated uniformly with other numerical dimension scores.

[0106] The preset dimension order refers to the arrangement of scores from various dimensions (such as efficiency, quality, and consistency) within a vector when combining multidimensional evaluation vectors. For example, it can be defined as [efficiency score, quality score, consistency score] or [quality score, efficiency score, consistency score]. This order can be fixed or configured based on the application scenario or analytical needs. Its purpose is to provide a standardized data structure, facilitating subsequent storage, transmission, and analysis. Combining multidimensional evaluation vectors means integrating efficiency, quality, and consistency scores into a structured dataset according to the preset dimension order, typically in the form of an array, list, or vector. For example, if the efficiency score is 0.8, the quality score is 0.9, and the consistency score is 0.7, and the preset order is [efficiency, quality, consistency], then the combined vector will be [0.8, 0.9, 0.7]. This combination process unifies the agent's performance across different dimensions into a processable whole.

[0107] By employing the aforementioned technical solutions, and by assigning clear weights to the efficiency and quality dimensions, and by precisely calculating the quantitative indicators within the execution efficiency and result quality characteristics, the objectivity and accuracy of these two aspects of evaluation are ensured, avoiding biases caused by subjective judgment. Simultaneously, a consistency dimension processing strategy is introduced to standardize the complex logical consistency comparison results into quantifiable scores, enabling this key dimension to be incorporated into a unified evaluation system. Combining these dimension scores into a multi-dimensional evaluation vector according to a preset order not only achieves the structured integration of evaluation results across dimensions, facilitating subsequent storage, analysis, and decision-making, but also provides a precise and comprehensive data foundation for subsequent feedback-based optimization of the target planning logic based on evaluation verification results. This enhances the reliability, comparability, and intelligence level of the entire multi-agent application management method. This refined evaluation approach enables more accurate identification of the strengths and weaknesses of agent performance, better guides the evolution of knowledge graphs and the optimization of task execution plans, and ultimately achieves the evolutionary capability of becoming "smarter with use."

[0108] This application further proposes specific steps for arbitrating the conflict based on pre-defined conflict resolution rules, including: identifying the knowledge sources involved in the conflict and obtaining the credibility level and timeliness information of the knowledge sources; determining the priority of the knowledge sources involved in the conflict based on the credibility level and timeliness information; and making an arbitration decision to accept or reject the knowledge involved in the conflict based on the priority.

[0109] Specifically, "identifying the knowledge sources involved in the conflict" aims to clarify the specific information source that triggered the knowledge conflict. For example, when contradictory information appears in a co-evolutionary knowledge graph, it is possible to trace which agent, external data interface, or historical task introduced this information. Simultaneously, "obtaining the credibility level of the knowledge source" refers to assessing the reliability of the information source. This can be achieved in various ways. For instance, the credibility level can be preset based on the type of knowledge source, such as expert-generated data having higher credibility than ordinary user input. Alternatively, the credibility level can be dynamically assessed and updated based on the knowledge source's performance in historical task executions (such as the accuracy and error rate of the information it provides). Furthermore, "obtaining the timeliness information of the knowledge source" refers to determining the freshness or expiration date of the information. For example, the timestamp of knowledge generation or last update can be recorded, and its obsolescence can be determined based on a preset decay model or time threshold. Alternatively, for certain knowledge with high timeliness requirements, it can be periodically compared with real-time data sources to verify its validity.

[0110] Based on this, "determining the priority of knowledge sources involved in the conflict based on the credibility level and the timeliness of the information" aims to comprehensively consider the reliability and freshness of knowledge, providing an objective basis for conflict resolution. For example, a weighted summation method can be used, assigning different weights to the credibility level and timeliness of the information for a comprehensive score, with higher scores indicating higher priority. Alternatively, a priority matrix or decision tree can be predefined, directly mapping different combinations of credibility level and timeliness of information to preset priority levels, such as "high priority," "medium priority," or "low priority."

[0111] "Arbitration decisions based on priority, allowing for the adoption or rejection of knowledge involved in the conflict" refers to making a final conflict resolution decision based on established priorities to ensure the internal consistency of the co-evolving knowledge graph. For example, when two pieces of knowledge conflict, the knowledge with higher priority can be adopted directly, while the knowledge with lower priority can be rejected. Alternatively, if the priorities of the conflicting knowledge are the same, contextual information can be introduced to assist in the judgment, or human intervention can be triggered for a final ruling.

[0112] Through the above technical solution, this application can dynamically and objectively handle knowledge conflicts. By identifying knowledge sources and obtaining their credibility level and timeliness information, the reliability and freshness of conflicting knowledge can be comprehensively assessed, avoiding misjudgments caused by outdated information or unreliable sources. Based on this, the priority of knowledge sources is determined according to credibility level and timeliness information, making the arbitration decision-making process more intelligent and automated, reducing the uncertainty caused by subjective intervention. Arbitration decisions based on priority for adoption or rejection ensure that the co-evolutionary knowledge graph maintains a high degree of consistency and accuracy throughout its continuous evolution, thereby improving the decision-making quality and operational efficiency of multi-agent applications in complex task scenarios.

[0113] This application further proposes a management method for multi-agent applications that integrates graph orchestration and expert capabilities. Based on the evaluation and verification results, the decision-making chain formed during the task execution process is integrated into a co-evolutionary knowledge graph in the form of nodes and relationships. (See [link to relevant documentation]). Figure 5 Specifically, it includes: 501. Based on user task input, create corresponding task nodes in the decision and evolution subgraph of the co-evolutionary knowledge graph.

[0114] 502. Based on the graph-based task execution plan and evaluation verification results, create decision nodes for each key decision step in the task execution process, and create an agent invocation node for each called agent.

[0115] 503. In the co-evolutionary knowledge graph, based on the actual execution logic and data flow of the decision-making link, create causal relationship edges connecting task nodes, decision nodes, agent calling nodes, and structured execution result nodes.

[0116] 504. Associate the performance data and conflict resolution conclusions from the evaluation and verification results with the corresponding nodes and edges in the decision-making chain as attributes.

[0117] Specifically, when creating corresponding task nodes in the decision and evolution subgraph of the co-evolutionary knowledge graph based on user task input, the task node is an entity in the co-evolutionary knowledge graph used to represent the starting point of a user task input. Its role is to record the source and context of the task, serving as the starting point of the entire task execution chain, facilitating subsequent traceability and management. One implementation is to automatically parse the unique identifier, timestamp, user ID, and other metadata of the task upon receiving user task input, and create a new node in the decision and evolution subgraph of the co-evolutionary knowledge graph. This node is labeled as "task," and its metadata is stored as node attributes. Another implementation is that, in addition to basic metadata, the task node can further include a detailed description of the task, objectives, priorities, and other information. This information can be extracted from the user task input or stored after semantic parsing using natural language processing techniques.

[0118] Based on the graph-based task execution plan and evaluation results, decision nodes are created for each key decision step in the task execution process, and agent invocation nodes are created for each invoked agent. Decision nodes represent key decision points during task execution, such as which agent to select or which strategy to adopt. Agent invocation nodes represent events where a specific agent is invoked during task execution. The creation of these nodes aims to structurally record the intermediate processes of task execution and the actual participation of agents, providing fine-grained data for subsequent performance analysis and knowledge accumulation. One implementation approach is to create a decision node in the knowledge graph whenever a step requiring selection or judgment (such as branch conditions or agent selection) is encountered during the execution of the graph-based task execution plan, recording the input, output, and result of that decision. Simultaneously, when the plan specifies the invocation of a specific agent, an agent invocation node is created, recording the invoked agent ID, invocation parameters, etc. Another approach is to further subdivide decision nodes into "strategy selection decision nodes," "resource allocation decision nodes," etc., based on their functions. Agent call nodes can contain agent version information, call duration, etc. The creation of these nodes can be based on predefined templates or through runtime log parsing.

[0119] In co-evolutionary knowledge graphs, when creating causal edges connecting task nodes, decision nodes, agent invocation nodes, and structured execution result nodes based on the actual execution logic and data flow of the decision-making chain, these causal edges represent the logical dependencies and execution order between them. The aim is to clarify the task execution process and data flow, construct a complete decision-making chain, and ensure the knowledge graph accurately reflects the actual execution path of the task from start to finish. One implementation involves creating edges with "trigger" semantics between task nodes and the first decision node; edges with "invocation" semantics between decision nodes and agent invocation nodes; edges with "generation" semantics between agent invocation nodes and structured execution result nodes; and edges with "preceding" or "following" semantics between logically dependent decision nodes based on their sequential relationships. Another implementation allows for more detailed edge classification based on actual execution logic, such as "selection," "execution," and "output," and can include attributes like timestamps and data dependencies to provide richer contextual information.

[0120] When linking performance data and conflict resolution conclusions from the evaluation and verification results to corresponding nodes and edges in the decision-making chain as attributes, the aim is to attach the evaluation and verification results (including performance data and conflict resolution conclusions) as attributes to the relevant nodes and edges in the decision-making chain. This enriches the information of the decision-making chain in the knowledge graph, providing quantitative and qualitative basis for subsequent feedback-based optimization, enabling the learning of which decisions are correct and which are ineffective. One implementation is to add the agent's execution performance data (such as response time, resource consumption, accuracy, etc.) as attributes to the corresponding agent calling node. Success or failure flags for decisions and the final conflict resolution conclusion are added as attributes to the decision node. Another implementation is that these attributes can be stored as key-value pairs, such as {"performance score": 0.95, "conflict conclusion": "adopt new data"}, and can be indexed and queried for subsequent analysis and decision-making.

[0121] Through the above technical solutions, the starting point and context of a task are clearly defined by creating task nodes, facilitating traceability. The creation of decision nodes and agent invocation nodes meticulously records key decision points and the actual participation of agents during task execution, preventing information omissions. The creation of causal edges clearly depicts the logical and data flow of task execution, making the structured representation of the entire decision-making chain more complete and accurate. By associating evaluation and verification results as attributes to nodes and edges, quantitative performance data and qualitative conflict resolution conclusions are provided for each decision step and agent invocation, enabling the knowledge graph to not only record "what happened," but also "how it worked" and "why it did so." This comprehensive and structured fusion approach greatly enhances the co-evolutionary knowledge graph's ability to reflect actual execution logic, providing a high-quality, highly reliable data foundation for subsequent feedback-based optimization of goal planning logic, and strengthening the "the more you use, the smarter it becomes" evolutionary capability of multi-agent systems.

[0122] This application further proposes a more precise and complete fusion mechanism, namely, based on the graph-based task execution plan and evaluation verification results, creating decision nodes for each key decision step in the task execution process, and creating an agent invocation node for each called agent.

[0123] Specifically, the mechanism includes the following steps: Parsing the graph-based task execution plan reveals all steps that lead to changes in execution path branches or agent selection, which are then identified as critical decision steps. Critical decision steps refer to nodes or operations in the graph-based task execution plan that branch the task execution path, select different agents, or alter execution logic. These steps are key points requiring judgment, selection, or scheduling during task execution, directly impacting the direction of subsequent tasks and resource allocation. In practice, these critical decision steps can be identified in several ways. For example, one approach is to traverse the graph structure of the graph-based task execution plan to identify nodes with multiple outgoing edges (representing path branches) or whose metadata contains conditional judgments or agent selection logic. If a node connects to two or more different subsequent task nodes, it can be considered a critical decision step. Another approach is to pre-label certain types of nodes (such as "conditional judgment nodes," "agent scheduling nodes," and "policy selection nodes") during the construction of the graph-based task execution plan, and then directly select nodes with these specific labels as critical decision steps during parsing.

[0124] For each key decision-making step, a decision node is created in the decision and evolution subgraph of the co-evolutionary knowledge graph. The adoption or rejection conclusion of the key decision step in the evaluation and verification results is associated with the decision node as an attribute. A decision node is an entity in the co-evolutionary knowledge graph used to record specific decision-making behaviors. Creating decision nodes aims to explicitly represent the key choices or judgments made during task execution in the knowledge graph, thereby enabling the tracing of the decision's origin and development. Associating the adoption or rejection conclusion in the evaluation and verification results with these decision nodes as attributes records the effectiveness or rationality of the decision in this task execution, providing direct feedback for subsequent knowledge evolution and optimization. For example, when creating a decision node, an attribute field, such as "Decision Result," can be defined, and the "Adoption" or "Rejection" string from the evaluation and verification results can be directly stored in this attribute field. In addition, attributes such as "Decision Time" and "Decision Maker (or Human)" can be added. Alternatively, besides node attributes, decision results can be represented by creating specific types of relationships. For example, a relationship can be derived from the decision node to the "success" or "failure" node of this task execution. The relationship type can be "leads to success" or "leads to failure".

[0125] For each agent invoked in the graph-based task execution plan, an agent invocation node is created in the co-evolutionary knowledge graph. The performance data corresponding to the agent from the evaluation and verification results is associated with this invocation node as an attribute. An agent invocation node is an entity in the co-evolutionary knowledge graph used to record which specific agent is invoked to execute a task. Creating this node aims to clearly record which agent is activated at which key step and its specific performance in the task. Associating the performance data corresponding to the agent from the evaluation and verification results as attributes with these nodes quantifies the agent's performance in actual execution, including but not limited to execution efficiency and result quality. This is crucial for evaluating the suitability of agents, optimizing agent selection strategies, and iteratively upgrading the agents themselves. For example, when creating an agent invocation node, multiple attribute fields can be added, such as "execution time," "resource consumption," "output quality score," and "error rate," and the corresponding performance data extracted from the evaluation and verification results can be directly populated into these attribute fields. Alternatively, the agent invocation node can include a link or ID pointing to an external performance report or log, which can be used to retrieve detailed performance data when needed. The node itself can store a summary performance score.

[0126] Through the above technical solutions, this application can accurately identify all steps in the graph-based task execution plan that lead to changes in execution path branches or agent selection, thereby solving the problem of ambiguity in identifying key decision points. This allows the knowledge graph to focus on the decision points that truly affect the task execution logic, avoiding interference from irrelevant operations and ensuring the accuracy of decision chain fusion. Simultaneously, by creating decision nodes for each key decision step and associating the adoption or rejection conclusions in the evaluation and verification results as attributes, a close integration of node creation and evaluation feedback is ensured. This allows the knowledge graph to clearly record the validity of each decision, providing direct and quantitative evidence for subsequent analysis of the reasons for decision success or failure and optimization of decision-making strategies. Furthermore, by creating agent call nodes for each agent called in the graph-based task execution plan and associating the performance data corresponding to the agent in the evaluation and verification results as attributes, the details of the agent's participation in task execution and quantitative performance indicators are accurately captured. This helps to evaluate the agent's contribution, identify its advantages and disadvantages, and provides data support for future optimization of agent selection and scheduling strategies. Overall, through the aforementioned precise identification, node creation, and attribute association mechanisms, this application ensures the accuracy and completeness of the decision-making chain integration into the co-evolutionary knowledge graph. This not only improves the reliability of the knowledge graph, enabling it to more realistically reflect the task execution process and results, but also lays a solid foundation for subsequent feedback-based optimization based on the knowledge graph, thereby realizing the evolutionary capability of multi-agent systems to become "more intelligent with use".

[0127] This application further proposes creating causal relationship edges connecting task nodes, decision nodes, agent invocation nodes, and structured execution result nodes in a co-evolutionary knowledge graph based on the actual execution logic and data flow of the decision-making chain. Specifically, this includes: creating causal relationship edges with triggering semantics between task nodes and the first decision node in the co-evolutionary knowledge graph, based on the actual execution order of the decision-making chain; creating causal relationship edges with adoption or rejection semantics between preceding and subsequent decision nodes for adjacent decision steps with logical dependencies; creating causal relationship edges with invocation semantics between the decision node corresponding to the decision step that invokes the agent and the agent invocation node of the agent; and creating causal relationship edges with generation semantics between the agent invocation node and the structured execution result node generated by the agent.

[0128] The creation of causal edges with trigger semantics aims to explicitly identify the causal relationship between task initiation and the first decision step. This trigger semantics can be represented as a specific relationship type in the knowledge graph, such as "triggers" or "initiates," directly connecting task nodes and the first decision node. Alternatively, this specific initiation relationship can be represented by adding an attribute label, such as "semantic: trigger," to a general causal edge.

[0129] Create causal edges with either acceptance or rejection semantics to precisely record the logical dependencies and outcome states between adjacent decision steps. Causal edges with acceptance semantics can be represented as relationships such as "accepts" or "leads to acceptance," indicating that a positive outcome of a preceding decision leads to the execution of a subsequent decision. Causal edges with rejection semantics can be represented as relationships such as "rejects" or "leads to rejection," indicating that a negative outcome of a preceding decision leads to the execution or termination of a subsequent decision. Alternatively, this can be achieved by attaching the attribute "Decision Result: Acceptance" or "Decision Result: Rejection" to general causal edges.

[0130] Creating causal edges with invocation semantics aims to clearly express how a decision step triggers the agent's execution. These causal edges with invocation semantics can be defined as specific relationship types such as "invokes" or "executes_agent," directly connecting the decision node to the invoked agent node. Alternatively, an attribute, such as "operation: invocation," can be added to the general causal edge to indicate that the causal relationship represents an agent invocation behavior.

[0131] Create causal edges with generative semantics to clarify the relationship between agent operations and their outputs. Generative causal edges can be represented as relation types such as "generates" or "produces," connecting the agent's invoking node to the structured execution result node produced by that agent. Alternatively, an attribute label, such as "semantic: generate," can be added to a generic causal edge to indicate the causal relationship of the agent's output.

[0132] By employing the aforementioned technical solutions, edges triggering semantics are created based on the actual execution sequence of the decision-making chain, ensuring that the logical starting point of the task initiation decision-making process is accurately captured and preventing chain breaks caused by ambiguity in the starting point. Edges for adoption or rejection semantics are created for adjacent decision steps with dependencies, accurately mapping the logical dependencies and result states between decisions and preventing omissions or incorrect associations of dependencies. Edges for call semantics are created between the decision node that executes the calling agent and the agent calling node, clearly recording how the decision triggers agent execution and enhancing the traceability of call relationships. Edges for generation semantics are created between the agent calling node and the execution result node, clearly linking agent operations and their output results, ensuring the integrity and consistency of data flow. These measures collectively achieve a refined semantic definition of causal relationship edges, enabling the co-evolutionary knowledge graph to truly and accurately reflect the decision-making chain, providing a reliable foundation for subsequent feedback-based optimization, and further optimizing the generation of subsequent graph-based task execution plans. This allows the management methods for multi-agent applications to achieve an evolutionary capability of "becoming smarter with use."

[0133] This application further proposes a feedback-based optimization of the target planning logic based on the newly added content and structural relationships contained in the fused co-evolutionary knowledge graph. (See [link to relevant documentation]). Figure 6 The optimization process includes: 601. Identify and extract successful decision patterns directly associated with the successful completion of user task input from the relationship between newly added content and structure.

[0134] 602. Based on the node attributes in the newly added content, statistically analyze the performance data of different agents or combinations of agents when performing the same type of task.

[0135] 603. Based on successful decision-making patterns and performance data, update the strategy knowledge base and performance reference data relied upon by the goal planning logic when making planning decisions.

[0136] Specifically, when identifying and extracting successful decision patterns directly associated with the successful completion of user task input from newly added content and structural relationships, these newly added content and structural relationships refer to new nodes (e.g., task nodes, decision nodes, agent invocation nodes, structured execution result nodes) and edges (e.g., causal relationship edges) integrated into the co-evolutionary knowledge graph through the aforementioned task execution process, as well as the connections formed between these new elements and existing graph elements. These newly added content and structural relationships collectively record the complete decision-making chain and result of this task execution. The successful decision pattern refers to a subgraph pattern in the knowledge graph that leads to the successful completion of the user task, possessing specific structural and semantic features, including decision nodes, agent invocation nodes, and their interconnections (causal relationship edges). It represents the path of agent collaboration and decision-making in a specific task scenario. Identifying and extracting this pattern can be achieved in various ways. For example, a depth-first search or breadth-first search can be performed on the fused co-evolutionary knowledge graph, starting from the task node marked "successful," and traversing back or forward along the causal relationship edges to construct a decision-making chain subgraph related to the successful task. Graph pattern matching algorithms (e.g., subgraph isomorphism detection or graph neural networks) can be used to identify recurring node sequences and edge relationships with specific topological structures and semantic labels in these subgraphs, thereby abstracting general successful decision-making patterns. Alternatively, a series of predefined rules or heuristic algorithms can be defined, such as identifying frequently occurring agent call sequences or specific decision branch combinations in successful task execution. Simultaneously, feature engineering can be performed on nodes and edges in the decision-making chain to extract their attributes (such as decision type, agent function, data flow direction, etc.), and then association rule mining algorithms (such as the Apriori algorithm) can be used to discover strong correlations between these features, thus forming successful decision-making patterns.

[0137] When analyzing the performance data of different agents or agent combinations performing similar tasks based on node attributes in newly added content, these node attributes refer to the additional information carried by nodes (especially agent invoking nodes and decision-making nodes) integrated into the co-evolutionary knowledge graph during task execution. These attributes may include, but are not limited to, agent execution time, resource consumption, output quality scores, decision adoption or rejection status, and conflict resolution results. These attributes form the basis for quantifying agent performance. The performance data refers to performance indicators of agents or agent combinations under specific task types, obtained through the aggregation and analysis of the aforementioned node attributes. Examples include average response time, task success rate, resource utilization, error rate, and knowledge contribution. This data reflects the agent's performance in actual operation. Various methods can be used to collect this data. For example, the co-evolutionary knowledge graph can be queried to filter out all agent invoking nodes or agent combination nodes performing similar tasks. Then, the attributes recorded on these nodes, such as execution time, resource consumption, and result quality scores, can be aggregated and calculated, such as calculating the mean, median, and standard deviation, to obtain overall performance data. Alternatively, more complex statistical methods can be used, such as multi-dimensional analysis of the performance data of different agents under different task types. For example, clustering algorithms can be used to identify groups of agents with similar performance, or time series analysis methods can be used to predict the future trend of agent performance.

[0138] When updating the strategy knowledge base and performance reference data relied upon by the goal planning logic for planning decisions based on successful decision-making patterns and performance data, the strategy knowledge base refers to the set of rules, heuristic algorithms, decision trees, or predefined workflow templates used by the goal planning logic to generate graph-based task execution plans. It includes high-level strategy information such as how to decompose user tasks, how to select agents, and how to orchestrate agent collaboration. The performance reference data refers to quantitative data such as agent performance benchmarks, collaborative efficiency scores, and resource consumption predictions used by the goal planning logic when evaluating candidate task flows, selecting the optimal agent, or optimizing execution paths. This data helps the planning logic conduct more accurate cost-benefit analyses. Updating these knowledge bases and data can be achieved in various ways. For example, newly identified successful decision-making patterns can be added to the strategy knowledge base as new rules or templates. For instance, if a certain agent combination is found to be consistently successful under a specific task type, it can be solidified as a preferred strategy. Simultaneously, based on statistically obtained agent performance data, the agent weights, priority parameters, or cost models in the performance reference data can be adjusted to more accurately reflect the actual performance of the agents. Alternatively, the strategy knowledge base and performance reference data can be viewed as a learnable model (e.g., a reinforcement learning-based planning model or a graph neural network model). In this case, successful decision-making patterns and performance data can be used as training samples or reward signals to incrementally retrain or fine-tune the model, enabling the goal-oriented planning logic to adaptively learn and optimize its planning and decision-making capabilities.

[0139] By identifying and extracting successful decision-making patterns directly associated with the successful completion of user tasks, the aforementioned technical solution enables the extraction of collaborative strategies from massive amounts of execution data, avoiding the limitations of manual experience summarization. Simultaneously, by statistically analyzing the performance data of agents based on node attributes in newly added content, objective and quantitative performance data is provided for the planning logic, ensuring that decisions are no longer dependent on static presets but rather on the actual operational performance of the agents. By feeding these successful patterns and performance data back to the strategy knowledge base and performance reference data, the goal planning logic can dynamically adjust its planning strategies and evaluation criteria, ensuring that the subsequently generated graph-based task execution plans are more efficient and reliable, and better adaptable to constantly changing task requirements and agent capabilities, thereby improving the overall intelligence and adaptability of multi-agent systems.

[0140] This application further proposes a method for identifying and extracting successful decision patterns directly associated with the successful completion of user task input from newly added content and structural relationships. The method includes the following steps: Locating the task node corresponding to the user task input in the decision and evolution subgraph of the co-evolutionary knowledge graph. Starting from the task node, traversing along causal edges and filtering out decision nodes and agent invocation nodes marked as successful. Based on the filtered decision nodes and agent invocation nodes, and the causal edges connecting these nodes, constructing a subgraph structure describing the successful execution. From the subgraph structure, summarizing recurring node type sequences and edge relationship combinations, and abstracting these node type sequences and edge relationship combinations into successful decision patterns.

[0141] Specifically, in the decision and evolution subgraph of the co-evolutionary knowledge graph, locating the task node corresponding to the user task input aims to ensure that the starting point of pattern extraction is directly related to the user task, thereby avoiding interference from irrelevant information and improving the targeting of extraction. This location process can be accomplished by querying the pre-defined task node types in the co-evolutionary knowledge graph and performing precise matching based on the unique identifier of the user task input (e.g., task ID, hash value of task name). Alternatively, it can be achieved by semantically parsing the user task input, extracting its core keywords or intent, and then performing fuzzy matching based on semantic similarity in the knowledge graph to find the most relevant task node.

[0142] Starting from the task node, the algorithm traverses and filters along the causal relationship edges to identify decision nodes and agent invocation nodes marked as successful. The core of this step is ensuring that the extracted patterns are based on actually successfully executed task paths, filtering out failed or incomplete paths to guarantee the validity and reliability of the summarized patterns. In implementation, graph traversal algorithms such as Depth-First Search (DFS) or Breadth-First Search (BFS) can be used. Starting from the located task node, the algorithm explores along the edges representing causal relationships in the knowledge graph. During the traversal, the attributes of each encountered decision node and agent invocation node are checked, filtering out those explicitly marked as "successful" or "completed." Another implementation method is to utilize the path query functionality provided by graph databases, for example, by constructing query statements using a specific query language (such as Cypher), specifying that the algorithm starts from the task node and searches along the causal relationship edges for decision nodes and agent invocation nodes whose execution status attribute is successful.

[0143] Based on this, a subgraph structure describing the successful execution is constructed using the selected decision nodes, agent calling nodes, and the causal edges connecting these nodes. The aim is to organize the selected discrete nodes and edges into a complete and meaningful graph structure, clearly demonstrating the complete decision-making chain and agent collaboration process of successful task execution, providing a structured foundation for subsequent pattern induction. Specifically, all selected successful decision nodes, agent calling nodes, and the causal edges directly connecting them can be extracted from the co-evolutionary knowledge graph to form a new, independent subgraph data structure. Alternatively, without actually copying the data, a view or logical subgraph can be defined, containing only the selected nodes and edges while maintaining references to the original knowledge graph, thus constructing the subgraph structure at the logical level.

[0144] From the subgraph structure, recurring sequences of node types and edge relationships are summarized, and these sequences and relationships are abstracted into successful decision patterns. This step aims to extract general and reusable decision patterns from specific successful execution cases. These patterns can guide the planning of similar tasks in the future, achieving knowledge generalization and reuse. For example, graph pattern mining algorithms, such as frequent subgraph mining or graph sequence pattern mining, can be used to analyze the constructed successful execution subgraphs. By setting a minimum support threshold, recurring sequences of node types (e.g., "Decision A - Agent B - Decision C") and edge relationship combinations (e.g., "Trigger-Call-Generate") in multiple successful subgraphs can be identified and abstracted into patterns. Another approach is to define a rule-based pattern matching engine, pre-set some common decision process templates, and then match successful execution subgraphs with these templates. For successfully matched templates, or through statistical analysis of the matching results, the most frequently occurring node types and edge relationship combinations can be identified and used as abstract successful decision patterns.

[0145] By employing the aforementioned technical solutions, the targeted nature of pattern extraction is ensured and interference from irrelevant information is avoided through locating task nodes in the decision-making and evolutionary subgraphs of the co-evolutionary knowledge graph. The reliability of the extracted patterns is guaranteed by traversing and filtering decision nodes and agent invocation nodes marked as successful execution states, ensuring they are based on verified successful experiences. Furthermore, constructing a subgraph structure describing this successful execution provides a complete decision-making link context, making pattern induction more comprehensive and accurate. By summarizing recurring node type sequences and edge relationship combinations, abstraction from specific cases to general patterns is achieved, enhancing the reusability and transferability of knowledge. These abstracted successful decision patterns can be directly used to update the policy knowledge base upon which the goal planning logic relies, thereby improving the decision quality and efficiency of the goal planning logic, optimizing the generation of subsequent graph-based task execution plans, and enabling multi-agent applications to achieve an evolutionary capability of "becoming smarter with use."

[0146] The following example will provide a more detailed explanation of the above technical solution: A smart home management system aims to provide users with device fault diagnosis and repair services. It integrates various intelligent agents, such as diagnostic agents, device control agents, knowledge query agents, and user interaction agents. It maintains a co-evolutionary knowledge graph, which records agent capabilities, device models, fault modes, historical task execution processes, and performance data.

[0147] Phase 1: Task Planning and Schedule Generation User A sends a request to the smart home management system via voice assistant: "My living room smart light bulb is not working, please help me fix it." This request is received as the user's task input. First, the current state of the co-evolutionary knowledge graph is analyzed. For example, the graph may record the latest operating status of the living room smart light bulb as "offline," but without a clear cause of failure. Simultaneously, based on the user's task input, the target graph state is determined to be "The living room smart light bulb has returned to normal operation."

[0148] By comparing the current state with the target state, the graph state difference is identified: namely, "the smart light bulb in the living room changes from offline to online and is fault-free." Based on this graph state difference, and combined with the historical performance data of the agent recorded in the co-evolutionary knowledge graph (e.g., the success rate of the diagnostic agent in handling light bulb faults, the average time taken for the device control agent to perform a restart operation, etc.), a graph-based task execution plan is dynamically generated through goal planning logic.

[0149] Specifically, the following steps will be performed: 1. Retrieve Historical Patterns: Analyze the differences in the graph state to identify the target entity node as "living room smart light bulb" and the target relationship type as "has state (offline)". Using "living room smart light bulb" as the query anchor, search for past task execution records for handling the "smart light bulb offline" problem in the decision and evolution subgraph of the co-evolutionary knowledge graph. Extract task execution path segments centered on "living room smart light bulb", such as "diagnose light bulb status - attempt to restart the light bulb - check power connection", as the historical task execution subgraph. Simultaneously, extract the policy nodes marked as successful in these path segments, such as "successful restart policy", as the successful policy pattern.

[0150] 2. Generate candidate task flow: Combine the retrieved historical task execution subgraphs with successful strategy patterns to form an initial task execution path template, such as "Diagnosis - Restart - Check Connection". Based on the agent's historical performance data, match one or more candidate agents that meet the performance criteria for each task node in the initial task execution path template. For example, the "Diagnosis" task can be matched with Diagnosis Agent 1 and Diagnosis Agent 2, and the "Restart" task can be matched with Device Control Agent 1.

[0151] Based on the collaboration records between one or more candidate agents (e.g., the historical collaboration efficiency scores between diagnostic agent 1 and device control agent 1 are high) and data interface constraints (e.g., the output data format of diagnostic agent 1 is compatible with the input data format of device control agent 1), the initial task execution path template is evolved. From the multiple candidate agents matched to each task node of the initial task execution path template, one agent is selected to obtain a first agent combination sequence (e.g., diagnostic agent 1 - device control agent 1). Based on the collaboration records, the historical collaboration efficiency scores between adjacent agents in the first agent combination sequence are determined, and the execution order of the agents in the first agent combination sequence is sorted according to the historical collaboration efficiency scores. Based on the data interface constraints, the input-output compatibility between adjacent agents in the sorted first agent combination sequence is verified, and the verified agent combinations and execution order are instantiated into a candidate task flow. The steps of determination, sorting, verification, and instantiation are repeated to obtain multiple different initial candidate task flows.

[0152] 3. Evaluation and Plan Selection: Evaluate one or more candidate task flows. First, perform a matching degree analysis between each candidate task flow and successful policy patterns in the co-evolutionary knowledge graph to obtain the pattern fit degree for each candidate task flow. Second, based on the agent's historical performance data, determine the risk level of knowledge conflict that each candidate task flow may generate with the co-evolutionary knowledge graph during execution.

[0153] Based on predefined optimization objectives (e.g., prioritizing success rate, followed by execution time, and strictly controlling knowledge conflict risk), a multi-objective trade-off decision is made regarding pattern fit and knowledge conflict risk level. Based on the predefined optimization objectives, optimization directions and trade-off thresholds are set for pattern fit and knowledge conflict risk level, respectively. Based on the optimization directions and trade-off thresholds, a set of feasible task flows that simultaneously meets the lower limit requirement of pattern fit and the upper limit requirement of knowledge conflict risk level is selected from one or more candidate task flows. For each feasible task flow in the set, a comprehensive trade-off index is determined for the feasible task flow in terms of both pattern fit and knowledge conflict risk level. Finally, the feasible task flow with the optimal comprehensive trade-off index is selected from the set of feasible task flows as the graph-based task execution plan for this task. For example, the selected plan is: "Diagnostic Agent 1 (diagnoses light bulb status) - Device Control Agent 1 (restarts light bulb) - Diagnostic Agent 1 (diagnoses light bulb status again)".

[0154] Phase Two: Agent Invocation and Task Execution Based on the selected graph-based task execution plan, at least one agent to be invoked is identified, and execution instructions containing relevant historical decisions and domain context are dynamically assembled for at least one agent from the co-evolutionary knowledge graph.

[0155] 1. Parsing Plan and Task Semantics: Read the graph structure data of the graph-based task execution plan and extract all nodes from the graph structure data. Based on the node type attribute of each node, select nodes whose node type is "agent invocation" from all nodes as agent invocation nodes, such as "invoke diagnostic agent 1" and "invoke device control agent 1". For each selected agent invocation node, extract the corresponding task objective description (e.g., "diagnose bulb status") and input data pattern (e.g., "device ID: [bulb ID]") from the node metadata of the graph-based task execution plan, and combine the task objective description and input data pattern into task semantics.

[0156] 2. Determine Context and Constraints: Perform semantic parsing on the task semantics to extract the task target entity "light bulb" and the core operation type "diagnosis". Map the task target entity to at least one target entity node type "smart device" in the co-evolutionary knowledge graph, and map the core operation type to at least one target relation type "having state" in the co-evolutionary knowledge graph. Combine at least one target entity node type and at least one target relation type to obtain the context type (e.g., "smart device state history"). Determine the allowed connection path patterns between at least one target entity node type and at least one target relation type in the co-evolutionary knowledge graph as association constraints.

[0157] 3. Query and extract context: Based on context type and relational constraints, query and extract relevant historical decision path fragments (e.g., the light bulb went offline in the past due to poor power contact and was successfully resolved by restarting) and domain fact nodes (e.g., the light bulb model, firmware version, connected gateway ID, etc.) from the co-evolutionary knowledge graph.

[0158] 4. Assemble and execute instructions: Structure and concatenate historical decision path fragments, domain fact nodes, and task semantics to obtain execution instructions for each agent calling the node. For example, the instruction for diagnostic agent 1 might include: "Task: Diagnose device status; Device ID: [light bulb ID]; Reference history: This device has successfully restarted due to a power problem; Current known: Device is offline." After receiving the instruction, the intelligent agent begins to execute the task. For example, diagnostic agent 1 first diagnoses the status of the smart light bulb in the living room, finding it indeed offline and initially determining that it might be a software malfunction. Subsequently, device control agent 1 receives the instruction and attempts to restart the smart light bulb. After the restart is complete, diagnostic agent 1 diagnoses again and finds that the bulb has returned to online status.

[0159] Phase 3: Outcome Evaluation and Knowledge Integration Obtain the structured execution result returned by at least one agent. For example, diagnostic agent 1 returns "The light bulb has been restored to online status, the fault has been resolved", and device control agent 1 returns "Restart operation successful".

[0160] 1. Performance Evaluation and Knowledge Consistency Verification: Based on pre-defined evaluation rules, the structured execution results are evaluated for performance and verified for knowledge consistency to obtain the evaluation and verification results. Execution efficiency features (e.g., total time of 5 seconds) and result quality features (e.g., fault resolution rate of 100%) are extracted from the structured execution results. The core conclusion in the structured execution results, "The smart light bulb in the living room is back online," is compared for logical consistency with the associated existing conclusion nodes in the co-evolutionary knowledge graph.

[0161] Based on preset evaluation rules, a multi-dimensional evaluation vector is obtained by comprehensively calculating the comparison results of execution efficiency features, result quality features, and logical consistency comparison. Specifically, based on the efficiency dimension weights in the preset evaluation rules, at least two quantitative indicators in the execution efficiency features are calculated to obtain the efficiency dimension score; based on the quality dimension weights in the preset evaluation rules, at least two quantitative indicators in the result quality features are calculated to obtain the quality dimension score; according to the consistency dimension processing strategy in the preset evaluation rules, the comparison results of logical consistency comparison are transformed to obtain the consistency dimension score; the efficiency dimension score, quality dimension score, and consistency dimension score are combined in a preset dimension order to obtain the multi-dimensional evaluation vector.

[0162] When a conflict is detected during logical consistency comparison (e.g., the graph records a light bulb firmware version A, but the agent reports firmware version B), the conflict is arbitrated based on pre-defined conflict resolution rules. Specifically, the knowledge sources involved in the conflict are identified, and their credibility level and timeliness information are obtained. Based on the credibility level and timeliness information, the priority of the knowledge sources involved in the conflict is determined. According to the priority, an arbitration decision is made to accept or reject the knowledge involved in the conflict. Finally, the multi-dimensional evaluation vector and the arbitrated conflict resolution conclusion are combined to form the evaluation and verification result.

[0163] 2. Decision-making link fusion: Based on the evaluation and verification results, the decision-making links formed during the execution of this task are fused into the co-evolutionary knowledge graph in the form of nodes and relationships.

[0164] Based on the user's task input "The smart light bulb in the living room is not working", a corresponding task node is created in the decision and evolution subgraph of the co-evolutionary knowledge graph.

[0165] Based on the graph-based task execution plan and evaluation results, decision nodes are created for each key decision step in the task execution process (e.g., "deciding to diagnose the light bulb," "deciding to restart the light bulb"), and agent invocation nodes are created for each invoked agent (e.g., "invoking diagnostic agent 1," "invoking device control agent 1"). Specifically, the graph-based task execution plan is parsed to obtain all steps in the plan that lead to changes in the execution path branches or agent selection, which are then considered key decision steps. For each key decision step, a decision node is created in the decision and evolution subgraph of the co-evolutionary knowledge graph, and the adoption or rejection conclusions of the key decision steps in the evaluation results are associated with the decision node as attributes. For each agent invoked in the graph-based task execution plan, an agent invocation node is created in the co-evolutionary knowledge graph, and the performance data corresponding to the agent in the evaluation results are associated with the agent invocation node as attributes.

[0166] In the co-evolutionary knowledge graph, causal edges connecting task nodes, decision nodes, agent invocation nodes, and structured execution result nodes are created based on the actual execution logic and data flow of the decision-making chain. Specifically, in the co-evolutionary knowledge graph, based on the actual execution order of the decision-making chain, causal edges with triggering semantics are created between task nodes and the first decision node; for adjacent decision steps with logical dependencies, causal edges with adoption or rejection semantics are created between preceding and subsequent decision nodes; causal edges with invocation semantics are created between the decision node corresponding to the decision step that invokes the agent and the agent invocation node; and causal edges with generation semantics are created between the agent invocation node and the structured execution result node generated by the agent.

[0167] The performance data and conflict resolution conclusions from the evaluation and verification results are associated with the corresponding nodes and edges in the decision-making chain as attributes.

[0168] Phase Four: Feedback-based Optimization Based on the new content and structural relationships included in the fusion of the co-evolutionary knowledge graph, the target planning logic is optimized through feedback.

[0169] 1. Identify Successful Decision Patterns: From the newly added content and structural relationships, identify and extract successful decision patterns directly associated with the successful completion of the user task input "The smart light bulb in the living room is not working". Specifically, in the decision and evolution subgraph of the co-evolutionary knowledge graph, locate the task node corresponding to the user task input; starting from the task node, traverse and filter along the causal relationship edges to identify decision nodes and agent calling nodes marked as successful; based on the selected decision nodes and agent calling nodes, and the causal relationship edges connecting these nodes, construct a subgraph structure describing this successful execution; from the subgraph structure, summarize the recurring node type sequences and edge relationship combinations, and abstract the node type sequences and edge relationship combinations into successful decision patterns.

[0170] 2. Statistical Performance Data: Based on the node attributes in the newly added content, statistical performance data of different agents or combinations of agents when performing similar tasks (e.g., diagnosing smart light bulb faults) is compiled. For example, the diagnostic agent 1 performed well in this task, and its success rate and efficiency data are updated.

[0171] 3. Update planning logic: Based on successful decision-making patterns and performance data, update the strategy knowledge base and performance reference data relied upon by the target planning logic when making planning decisions. For example, the next time a similar "smart bulb offline" problem is encountered, the planning logic will prioritize the task flow that includes the successful pattern of "diagnosis-restart-re-diagnosis", and will prioritize the diagnostic agent 1 and device control agent 1 that perform well in similar tasks.

[0172] Comparative analysis with related technologies: This solution dynamically generates graph-based task execution plans, enabling flexible adjustments to task flows and agent combinations based on real-time graph state differences and historical agent performance data. For example, when user A's smart light bulb malfunctions, it doesn't rigidly execute a pre-set fixed process. Instead, it dynamically plans a suitable diagnosis and repair path based on the bulb's current state, historical fault records, and the real-time performance of each agent. If an agent's performance declines or the environment changes, it automatically adapts and adjusts the plan, avoiding the tedious and inefficient manual reconfiguration. This solves the problem of poor adaptability caused by static orchestration paradigms in existing technologies.

[0173] This solution uses a co-evolutionary knowledge graph as a global collaborative hub to structurally accumulate and reuse decision-making links, agent performance data, and successful strategy patterns during task execution. For example, after user A's light bulb malfunction is resolved, the entire decision-making process, the agent's specific operations, execution results, and evaluation data are precisely integrated into the knowledge graph. This ensures the consistency of task objectives and avoids behavioral chaos that may result from autonomous agent collaboration. Each task execution provides experience and data for subsequent planning, enabling continuous optimization of the goal planning logic, thereby improving the controllability and reliability of complex tasks. This solves the problem of weak controllability caused by the decentralized evolutionary paradigm in existing technologies. This solution effectively addresses the systemic problems of "static rigidity" and "dynamic chaos" in existing technologies, achieving globally controllable orchestration and autonomous continuous optimization based on collective experience.

[0174] All of the above-mentioned optional technical solutions can be combined in any way to form the optional embodiments of this application, and will not be described in detail here.

[0175] Figure 7This is a schematic diagram of the structure of a management system 700 for multi-agent applications that integrates graph orchestration and expert capabilities, provided in an embodiment of this application. The management system 700 can vary significantly due to different configurations or performance characteristics. It may include one or more Central Processing Units (CPUs) 701 and one or more memories 702. Each memory 702 stores at least one computer program, which is loaded and executed by the one or more processors 701 to implement the methods provided in the various method embodiments described above. Of course, the management system 700 may also have wired or wireless network interfaces, a keyboard, and input / output interfaces for input and output. It may also include other components for implementing device functions, which will not be elaborated upon here.

[0176] The above are merely optional embodiments of this application and are not intended to limit this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the protection scope of this application.

Claims

1. A management method for multi-agent applications that integrates graph arrangement and expert capabilities, characterized in that, The method includes: The graph state difference between the target graph state corresponding to the user task input and the current state of the co-evolutionary knowledge graph is determined, and based on the graph state difference and the agent's historical performance data recorded in the co-evolutionary knowledge graph, a graph-based task execution plan is dynamically generated through goal planning logic. Based on the graph-based task execution plan, at least one agent to be invoked is determined, and execution instructions containing relevant historical decisions and domain context are dynamically assembled for the at least one agent from the co-evolutionary knowledge graph. The process involves: acquiring structured execution results returned by at least one agent; extracting execution efficiency features and result quality features from the structured execution results; comparing the core conclusions in the structured execution results with the associated existing conclusion nodes in the co-evolutionary knowledge graph for logical consistency; comprehensively calculating the execution efficiency features, result quality features, and the comparison results of the logical consistency comparison based on preset evaluation rules to obtain a multi-dimensional evaluation vector; arbitrating conflicts when the logical consistency comparison finds them based on preset conflict resolution rules; and combining the multi-dimensional evaluation vector with the arbitrated conflict resolution conclusion to form an evaluation verification result. Based on the evaluation and verification results, the decision-making chain formed during the execution of this task will be integrated into the co-evolutionary knowledge graph in the form of nodes and relationships; Based on the new content and structural relationships included in the fused co-evolutionary knowledge graph, the target planning logic is optimized through feedback.

2. The method of claim 1, wherein, The process of dynamically generating a graph-based task execution plan based on the differences in the graph state and the historical performance data of the agent recorded in the co-evolutionary knowledge graph, through goal planning logic, includes: Based on the graph state differences, retrieve historical task execution subgraphs and successful strategy patterns related to eliminating the graph state differences from the co-evolutionary knowledge graph; Using the historical task execution subgraph and success strategy pattern as a reference, and combining the agent's historical performance data, reasoning is performed to generate one or more candidate task flows; The one or more candidate task flows are evaluated based on predefined optimization objectives, and the graph-based task execution plan is selected based on the evaluation results.

3. The method of claim 2, wherein, The process of generating one or more candidate task flows by referencing the historical task execution subgraph and successful strategy patterns, combined with the agent's historical performance data, includes: The historical task execution subgraph is combined with the success strategy pattern to obtain the initial task execution path template; Based on the historical performance data of the intelligent agent, one or more candidate intelligent agents whose performance meets the standard are matched for each task node in the initial task execution path template; Based on the collaborative records and data interface constraints among the one or more candidate agents, the initial task execution path template is evolved to obtain multiple candidate task flows with different combinations of agents and execution orders.

4. The method of claim 1, wherein, The step of determining at least one agent to be invoked based on the graph-based task execution plan, and dynamically assembling execution instructions containing relevant historical decisions and domain context from the co-evolutionary knowledge graph for the at least one agent, includes: The graph-based task execution plan is parsed to obtain the calling node of each agent in the graph-based task execution plan and the corresponding task semantics; For each agent calling node, the context type and association constraints that need to be retrieved from the co-evolutionary knowledge graph are determined based on the task semantics. Based on the context type and the association constraints, relevant historical decision path fragments and domain fact nodes are queried and extracted from the co-evolutionary knowledge graph; The historical decision path fragments, the domain fact nodes, and the task semantics are structurally concatenated to obtain the execution instructions for each agent calling the node.

5. The method of claim 1, wherein, The method, based on preset evaluation rules, comprehensively calculates the execution efficiency features, the result quality features, and the comparison results of the logical consistency comparison to obtain a multi-dimensional evaluation vector, including: Based on the efficiency dimension weights in the preset evaluation rules, at least two quantitative indicators in the execution efficiency feature are calculated to obtain the efficiency dimension score. Based on the quality dimension weights in the preset evaluation rules, at least two quantitative indicators in the result quality characteristics are calculated to obtain the quality dimension score. According to the consistency dimension processing strategy in the preset evaluation rules, the comparison result of the logical consistency comparison is transformed to obtain the consistency dimension score. The efficiency dimension score, the quality dimension score, and the consistency dimension score are combined in a preset dimensional order to obtain the multidimensional evaluation vector.

6. The method of claim 1, wherein, The process of integrating the decision-making chain formed during the execution of this task into the co-evolutionary knowledge graph based on the evaluation and verification results, in the form of nodes and relationships, includes: Based on the user task input, a corresponding task node is created in the decision and evolution subgraph of the co-evolutionary knowledge graph; Based on the graph-based task execution plan and the evaluation and verification results, a decision node is created for each key decision step in the task execution process, and an agent invocation node is created for each invoked agent. In the co-evolutionary knowledge graph, based on the actual execution logic and data flow of the decision-making link, causal relationship edges are created connecting the task node, the decision node, the agent calling node, and the structured execution result node; The performance data and conflict resolution conclusions in the evaluation and verification results are associated with the corresponding nodes and edges in the decision-making link in the form of attributes.

7. The method of claim 6, wherein, Based on the graph-based task execution plan and the evaluation and verification results, a decision node is created for each key decision step in the task execution process, and an agent invocation node is created for each invoked agent, including: The graph-based task execution plan is analyzed to obtain all steps in the graph-based task execution plan that lead to changes in the execution path branches or agent selection, which are then used as the key decision steps. For each key decision step, a decision node is created in the decision and evolution subgraph of the co-evolutionary knowledge graph, and the adoption or rejection conclusion of the key decision step in the evaluation and verification results is associated with the decision node as an attribute. For each agent invoked in the graph-based task execution plan, an agent invocation node is created in the co-evolutionary knowledge graph, and the performance data corresponding to the agent in the evaluation and verification results is associated with the agent invocation node as an attribute.

8. The method of claim 1, wherein, The step of performing feedback-based optimization of the target planning logic based on the newly added content and structural relationships contained in the fused co-evolutionary knowledge graph includes: From the newly added content and the structural relationship, identify and extract successful decision patterns that are directly associated with the successful completion of the user task input; Based on the node attributes in the newly added content, statistical data on the performance of different agents or combinations of agents when performing the same type of task is collected. Based on the successful decision-making model and the performance data, update the strategy knowledge base and performance reference data that the target planning logic relies on when making planning decisions.

9. The method of claim 8, wherein, The step of identifying and extracting successful decision patterns directly associated with the successful completion of the user task input from the newly added content and the structural relationship includes: In the decision and evolution subgraph of the co-evolutionary knowledge graph, locate the task node corresponding to the user task input; Starting from the task node, traverse along the causal relationship edge and filter out the decision nodes and agent invocation nodes whose execution status is marked as successful; Based on the selected decision nodes and agent calling nodes, as well as the causal relationship edges connecting these nodes, a subgraph structure describing this successful execution is constructed. From the subgraph structure, the recurring sequence of node types and the combination of edge relationships are summarized, and the sequence of node types and the combination of edge relationships are abstracted into the successful decision-making pattern.

10. A management system for fusing graph orchestration with expert capabilities of multi-agent applications, the system comprising: The system includes one or more processors and one or more memories, wherein at least one computer program is stored in the one or more memories, and the computer program is loaded and executed by the one or more processors to implement the management method for multi-agent applications that integrate graph orchestration and expert capabilities as described in any one of claims 1-9.

Images