A multi-agent task processing method, device and equipment and a storage medium

Abstract

The application discloses a multi-agent task processing method and device, equipment and a storage medium, and relates to the technical field of artificial intelligence and large language model application. The multi-agent task processing method comprises the following steps: receiving a user request, clarifying the requirement of the user request with unclear definition through an interactive inquiry and feedback cycle until the definition of the user request meets a preset definition condition, generating a standardized instruction and a user confirmation based on the user request; decomposing the standardized instruction into subtask steps, matching a corresponding target agent for each subtask step from an agent resource pool; performing effectiveness review on the output results in the execution process of each target agent, and performing a correction process on the target agent that fails to pass the effectiveness review; and aggregating the execution results of each subtask step into a final result as the output to the user. In the foregoing manner, the application can overcome the defect that the capability of a single agent is limited, and improve the efficiency of complex task processing.

Description

Technical Field

[0001] This application relates to the fields of artificial intelligence and large language model application technology, and in particular to a multi-agent task processing method, apparatus, device and storage medium. Background Technology

[0002] With the continuous development of artificial intelligence technology, intelligent agents are increasingly widely used in fields such as automation, intelligent decision-making, and natural language processing. In actual enterprise business and complex task processing, the capabilities of a single intelligent agent are often limited by its own knowledge, functions, and computing resources, making it difficult to independently cope with ever-changing and massive business demands. Therefore, Multi-Agent Systems (MAS) have emerged, effectively improving the overall intelligence level and task processing capabilities of a system through the collaboration and division of labor among multiple intelligent agents.

[0003] However, existing multi-agent systems still have certain shortcomings in practical applications: First, when faced with vague user intentions, the system often executes directly, leading to deviations in results; second, the coupling between agents and tools is high, making it impossible to dynamically expand capabilities according to tasks; third, the lack of effective quality monitoring and self-correction mechanisms during task execution results in fragmented, illogical, or redundant outputs, and the problems of single agent capabilities being limited and poor system scalability have not been fundamentally solved. Summary of the Invention

[0004] This application mainly provides a multi-agent task processing method, apparatus, device and storage medium to solve the problems of single agent limited capabilities and poor system scalability.

[0005] To address the aforementioned technical problems, this application provides a multi-agent task processing method, comprising: receiving a user request and clarifying the user request with ambiguous clarity through an interactive query and feedback loop until the clarity of the user request meets a preset clarity condition; generating a standardized instruction based on the user request and confirming it with the user; decomposing the standardized instruction into at least one sub-task step and matching a corresponding target agent for each sub-task step from a preset agent resource pool; the target agent is used to execute each of the corresponding sub-task steps, and during execution, dynamically attaching and calling corresponding execution tools according to the target agent's professional capabilities; reviewing the validity of the output results of each target agent during execution, and performing a correction process on target agents that fail the validity review; and pruning, deduplicating, and logically concatenating the execution results of each sub-task step, and aggregating them into a final result as output to the user.

[0006] In some embodiments, matching a target agent for each subtask step from a pre-set agent resource pool includes: extracting the professional skill tags and tool preference tags required for the current subtask step; traversing the capability profiles of each candidate agent in the agent resource pool, the capability profiles including historical execution success rates and areas of expertise; calculating the matching score between the professional skill tags, tool preference tags and the capability profiles of each candidate agent, and determining the candidate agent with the highest matching score as the target agent.

[0007] In some embodiments, dynamically mounting and invoking the corresponding execution tool based on the target agent's expertise includes: when the target agent begins executing the sub-task step, reading a pre-configured tool registry, which stores a mapping relationship between tool identifiers and function descriptions; inputting the execution requirements of the sub-task step into the target agent's large language model, which outputs the target tool identifier to be invoked; obtaining the corresponding interface configuration from the tool registry based on the target tool identifier; and establishing a communication connection between the target agent and the execution tool to complete the mounting.

[0008] In some embodiments, the validity review of the output results during the execution of each target agent includes: obtaining the output result of the current subtask step and the corresponding original subtask step requirements; inputting the output result and the original subtask step requirements into a preset review module, which scores the results from three dimensions: completeness, accuracy, and logical consistency; determining whether the comprehensive score of the three dimensions reaches a preset passing threshold; if it does not reach the threshold, the validity review is deemed to have failed.

[0009] In some embodiments, the process of performing a correction procedure on the target agent that fails the validity review includes: sending the reason for the failure and the current output result to the target agent; triggering a reflection prompt word inside the target agent, causing the target agent to generate an error analysis report and a correction strategy based on the reason for failure; controlling the target agent to re-execute the current subtask step according to the correction strategy, and counting the number of retries.

[0010] In some embodiments, after counting the number of retries, the method further includes: determining whether the number of retries has reached the preset maximum number of retries and whether the validity review has still failed; if so, pausing the current task flow and generating a visual intervention page containing the current execution progress, historical output results and failure reasons, and sending it to the user; receiving the manual adjustment instruction entered by the user on the visual intervention page, and updating the current subtask steps or re-matching the target agent according to the manual adjustment instruction.

[0011] In some embodiments, the process of pruning, deduplicating, and logically concatenating the execution results of each subtask step includes: extracting the core conclusion paragraphs from each execution result according to the execution sequence of the subtask steps, and removing redundant reasoning process information to complete the pruning; cross-comparing the execution results of each subtask step, identifying and deleting semantically repetitive data entities in each execution result to complete the deduplication; constructing logical transition statements between each core conclusion paragraph in each execution result, and concatenating the deduplicated core conclusion paragraphs to form a coherent intermediate text.

[0012] To address the aforementioned technical problems, another technical solution adopted in this application is: providing a multi-agent task processing device for a multi-agent task processing method, comprising: a receiving module, configured to receive user requests and clarify unclear user requests through interactive inquiry and feedback loops until the clarity of the user request meets a preset clarity condition, generating standardized instructions based on the user request and confirming them with the user; a matching module, configured to decompose the standardized instructions into at least one sub-task step and match a corresponding target agent for each sub-task step from a preset agent resource pool; the target agent is used to execute each corresponding sub-task step, and during execution, dynamically attaches and calls corresponding execution tools according to the target agent's professional capabilities; a review module, configured to review the validity of the output results of each target agent during execution, and perform a correction process for target agents that fail the validity review; and a processing module, configured to trim, deduplicate, and logically concatenate the execution results of each sub-task step, and aggregate them into a final result as output to the user.

[0013] This application also provides a computer device, the computer device comprising: a memory and at least one processor, the memory storing instructions; the at least one processor calling the instructions in the memory to cause the computer device to execute a multi-agent task processing method.

[0014] This application also provides a computer-readable storage medium storing instructions that, when executed by a processor, implement the multi-agent task processing method described above.

[0015] The beneficial effects of this application are as follows: Unlike existing technologies, this application discloses a multi-agent task processing method, apparatus, device, and storage medium. By receiving user requests and clarifying ambiguous user requests through an interactive query and feedback loop until the clarity of the user request meets a preset clarity condition, standardized instructions are generated based on the user request and confirmed with the user. By introducing an interactive query and feedback loop state machine, the system can proactively and accurately eliminate ambiguity at the input end before consuming large-scale computing power for task reasoning. This achieves pre-emptive protection of computing resources, avoids invalid work by all subsequent agents due to initial misunderstanding bias, and significantly improves the success rate of the first execution of complex tasks.

[0016] By decomposing standardized instructions into at least one sub-task step and matching a corresponding target agent to each sub-task step from a pre-set agent resource pool, the system ensures that each micro-step is handled by a professional model with the best parameter adaptation and the richest fine-tuning data in the domain. This achieves a dimensionality reduction from general large models to expert small models, improving accuracy while reducing inference costs. The dynamic mounting mechanism allows agents to acquire external real-time data or call specialized computing engines on demand during runtime, completely breaking the limitations of closed-source knowledge blind spots in models.

[0017] By validating the output of each target agent during execution and implementing a correction process for those that fail the validity review, the system employs an automatic correction process based on reflective prompts. This endows the system with self-correcting cognitive abilities similar to human experts, enabling the automatic elimination of most common errors without human intervention. This balances system autonomy with the security of human intervention, ensuring that even in extreme and abnormal situations, the task flow will not deadlock but can instead return to the correct track with the help of human intelligence.

[0018] By trimming, deduplicating, and logically connecting the execution results of each subtask step, and aggregating them into the final result as the output to the user, information redundancy at the data level is eliminated, ensuring the uniqueness of the factual statements. Through logical connection processing, the technical effect is to give fragmented information a macroscopic structure of temporal evolution or causal progression, making the final output text have the high coherence and readability of professional analysts, and completely solving the fatal defect of the heavy splicing of multi-agent system output. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the 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, wherein: Figure 1 This is a flowchart illustrating the multi-agent task processing method provided in this application; Figure 2 This is a schematic diagram of the structure of the multi-agent task processing device provided in this application; Figure 3 This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. Detailed Implementation

[0020] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of the embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of this application.

[0021] The terms "first," "second," and "third" used in the embodiments of this application are for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first," "second," or "third" may explicitly or implicitly include at least one of that feature. In the description of this application, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products, or devices.

[0022] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a mutually exclusive, independent, or alternative embodiment. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0023] See Figure 1 , Figure 1This is a flowchart illustrating the multi-agent task processing method provided in this application. This application provides a multi-agent task processing method based on a system where multiple agents collaborate to complete complex tasks. This system is suitable for fields that utilize multiple large language models to solve complex problems. With the continuous development of Artificial Intelligence (AI) technology, agents are increasingly widely used in automation, intelligent decision-making, and Natural Language Processing (NLP). In actual enterprise business and complex task processing, the capabilities of a single agent are often limited by its own knowledge, functions, and computing resources, making it difficult to independently cope with changing and massive business demands. Therefore, Multi-Agent Systems (MAS) have emerged, effectively improving the overall intelligence level and task processing capabilities of the system through the collaboration and division of labor among multiple agents. The purpose of this application is to overcome the shortcomings of existing technologies and design a system with multiple agents possessing different capabilities and adapted to different scenarios. This system completes complex tasks through the collaborative division of labor among multiple agents, expanding the capabilities of large models. Different agents can be matched according to different task types, solving the problems of single agent capabilities and poor scalability. The multi-agent task processing method specifically includes the following steps: 100: Receive user requests and clarify unclear user requests through interactive questioning and feedback loops until the clarity of the user request meets the preset clarity conditions. Then, generate standardized instructions based on the user request and confirm with the user.

[0024] In a specific implementation of step 100, requirement initialization and clarification are the starting point for the entire multi-agent system to handle complex tasks. In enterprise-level application scenarios, user-input requests often exhibit highly unstructured characteristics, potentially containing numerous colloquial expressions, missing key entities, contradictory constraints, or vague business objectives. Directly inputting such vague requests into the downstream planning module will inevitably lead to task decomposition errors, agent matching biases, and complete failure of the final output. Therefore, step 100 employs a rigorous natural language understanding and multi-turn dialogue state tracking mechanism to ensure that every task entering the system has clear boundaries, a clear intent, and complete constraints.

[0025] Specifically, upon receiving a user request, the system first preprocesses the original request. This preprocessing stage includes text cleaning and normalization operations, such as removing meaningless whitespace characters, correcting common typos, and converting full-width characters to half-width characters to ensure consistency in subsequent processing. Subsequently, the system calls a pre-built basic intent recognition model to perform preliminary parsing of the request. This intent recognition model, built on a deep learning network, is capable of extracting core verb phrases and associated noun entities from the user request. Based on the extracted features, the system calculates the clarity score of the user request.

[0026] The clarity score calculation relies on a multi-dimensional evaluation system. The first dimension is entity completeness, where the system checks whether the request contains the key elements necessary to achieve a specific business objective. For example, if the request involves data querying, it must include entities such as the time range, target data metrics, and data source; if it involves code generation, it must include the programming language type, core function description, and input / output interface definitions. The proportion of missing key entities will directly translate into a deduction in the clarity score. The second dimension is constraint clarity, where the system uses semantic dependency parsing to analyze whether there are unclear modifiers, ambiguous conditional branches, or undefined priorities in the request. The third dimension is feasibility, where the system compares the extracted intent with a pre-defined business capability boundary database to determine whether the request exceeds the system's capabilities or contains obvious logical paradoxes.

[0027] When the calculated sharpness score is lower than the threshold corresponding to the preset sharpness condition, the system determines that the user's request is in a blurry state and automatically triggers an interactive question and feedback loop. In this loop, the system does not randomly or simply ask the user to supplement information, but generates highly targeted and guiding rhetorical questions based on the missing information analysis of the above three dimensions.

[0028] For example, if a time range entity is detected to be missing, the system will directly construct an option-based question containing the current date to guide the user in defining the time boundaries.

[0029] After a user responds to a question, the system concatenates the current response text with the historical dialogue context and recalculates the overall clarity score. This process is repeated until the clarity score meets the preset clarity criteria.

[0030] Once the clarity meets the preset clarity requirements, the system enters the standardized instruction generation stage. Standardized instructions are the process of converting natural language into structured data that machines can precisely execute. The system utilizes the instruction compliance capabilities of a large language model, combined with predefined JSON or XML templates, to map the clarified user requirements into a standardized data structure containing specific fields. This standardized data structure includes at least a core task identifier field, a sub-objective list field, a constraint set field, and an expected output format field. After generating the standardized instruction, the system displays it as a user-readable structured summary through the user interface, along with a confirmation option. Only after receiving explicit confirmation from the user is the standardized instruction officially locked and allowed to proceed to the next processing step. Through this rigorous interactive clarification and structured confirmation mechanism, this step eliminates ambiguity at the source, significantly reducing rework rates in downstream task execution and improving the overall system execution efficiency and resource utilization.

[0031] 200: Decompose standardized instructions into at least one sub-task step, and match a corresponding target agent for each sub-task step from a pre-set agent resource pool. The target agent is used to execute the corresponding sub-task steps, and during execution, the corresponding execution tools are dynamically attached and invoked based on the target agent's expertise.

[0032] In a specific implementation of step 200, task decomposition and role assignment are the core elements of realizing the divide-and-conquer strategy for multiple agents. Faced with complex business processes, the system must break down the overall macro-task into micro-subtasks with appropriate granularity, clear boundaries, and low coupling, and assign them suitable execution entities and toolsets.

[0033] In an optional embodiment of step 200, matching a corresponding target agent for each subtask step from a preset agent resource pool includes the following steps: 210: Extract the professional skill tags and tool preference tags required for the current subtask step.

[0034] In step 210, the system performs in-depth feature engineering on each of the decomposed subtask steps. For each subtask step, the system extracts two key label systems using sequence labeling and text classification models from natural language understanding technology. The first type is professional skill labels, which represent the hard knowledge and cognitive abilities necessary to complete the subtask. For example, for a subtask that requires obtaining the latest information from the internet, the system extracts professional skill labels such as real-time information retrieval, web page text parsing, and cross-language understanding; for a subtask that requires data statistical analysis, the system extracts professional skill labels such as mathematical logic reasoning, Python programming, and data structure processing. The second type is tool preference labels, which represent the types of external entity tools that the subtask is most likely to rely on in the execution path. For example, the extracted labels may include Structured Query Language (SQL) executors, Application Programming Interface (API) gateways, local file read / write interfaces, and sandbox code execution environments. The extraction of these tags is based not only on the textual semantics of the subtasks, but also on the statistics of successful execution paths of similar historical tasks, thereby ensuring the accuracy and foresight of the tag extraction.

[0035] 220: Traverse the capability profiles of each candidate agent in the agent resource pool. The capability profiles include historical execution success rates and areas of expertise.

[0036] In step 220, the system loads a pre-configured pool of intelligent agents into memory. This pool contains various models with different capabilities, pre-built by the system and dynamically expanded thereafter, including but not limited to insight writing experts, online search experts, coding integrated development environment experts, browser manipulation experts, customer service experts, and marketing experts.

[0037] Each candidate agent maintains a detailed capability profile during registration. This capability profile is a multi-dimensional set of feature vectors, which includes not only static descriptions of areas of expertise but also dynamically calculated historical execution success rates.

[0038] Domain expertise is quantified using domain entity nodes and associated weights in a knowledge graph. For example, a certain agent might have extremely high weights in knowledge nodes related to e-commerce. Historical execution success rates are updated in real-time using a sliding window algorithm. The system records the number of times each candidate agent has successfully executed various labeled tasks within a preset time period, calculating a dynamic success rate metric.

[0039] In addition, the capability profile also includes engineering-level features such as the agent's own parameter scale level, average response latency, and concurrent processing limit, providing a comprehensive reference for subsequent matching calculations.

[0040] 230: Calculate the matching score between professional skill tags, tool preference tags and the ability profiles of each candidate agent, and determine the candidate agent with the highest matching score as the target agent.

[0041] In step 230, the system employs a multi-factor weighted fusion algorithm to calculate the final matching score. Specifically, the system first calculates the semantic similarity between the professional skill label and the candidate agent's domain of expertise. Using a vector representation model based on the Transformer architecture, the skill label text and the domain of expertise text are mapped into high-dimensional dense vectors, respectively. The skill matching score is obtained by calculating the cosine similarity between the two vectors. Secondly, the system calculates the Jaccard similarity coefficient between the tool preference label and the candidate agent's historical tool call records to obtain the tool matching score. Subsequently, the system incorporates the dynamic historical execution success rate as a penalty or reward factor into the calculation model.

[0042] The final matching score is calculated as follows: the total score equals the skill matching score multiplied by the first weighting coefficient, plus the tool matching score multiplied by the second weighting coefficient, plus the historical execution success rate multiplied by the third weighting coefficient, while subtracting the response latency penalty.

[0043] The system iterates through all candidate agents in the resource pool, calculates their total scores, and quickly extracts the candidate agent with the highest total score by constructing a max-heap data structure. This candidate agent is then officially designated as the target agent for this subtask step. This matching mechanism based on multi-dimensional quantitative scoring completely avoids the subjectivity and limitations of manually designating agents, achieves optimal allocation of computing resources and task requirements, and significantly improves the first-time success rate of individual subtask steps.

[0044] In another optional embodiment of step 200, the corresponding execution tool is dynamically mounted and invoked according to the professional capabilities of the target intelligent agent, including the following steps: 240: When the target agent begins to execute a subtask step, it reads the pre-configured tool registry, which stores the mapping relationship between tool identifiers and function descriptions.

[0045] In step 240, the dynamic tool mounting mechanism is a key technical means to expand the capability boundaries of the intelligent agent. When the target intelligent agent is assigned and ready to start execution, the system does not load all available tools into the context environment of the intelligent agent during the initialization phase. This is because an overly expanded context would not only interfere with the attention mechanism of the large language model, but also lead to unnecessary lexical consumption and inference delays. Instead, the system adopts a lazy loading strategy. At the beginning of execution, the target intelligent agent first initiates a read request to the central configuration center to obtain the pre-configured tool registry. This tool registry is stored in a key-value database or a high-performance caching system, where the key is a globally unique tool identifier and the value is a structured functional description of the tool. The functional description strictly follows the predefined description specifications, including the tool's category, applicable scenarios, input parameter pattern definitions, and output result format descriptions. For example, the functional description of a browser tool will specify in detail its ability to receive Uniform Resource Locator (URL) strings and interactive action instructions, and return plain text content extracted from the Document Object Model (DOM) tree. By reading the tool registry, the target agent can establish a global understanding of the currently available toolset.

[0046] 250: Input the execution requirements of the subtask steps into the large language model of the target agent, and the large language model outputs the target tool identifier to be called.

[0047] In step 250, the large language model within the target agent performs the reasoning process for tool selection. The system combines the standardized execution requirement text of the current subtask step, the context information of historical executions, and the tool registry content obtained in step 240 to construct a specific tool selection prompt. This prompt instructs the large language model to act as a tool scheduling decision-maker. When processing this prompt, the large language model utilizes its inherent semantic understanding and logical reasoning capabilities to analyze the core intent in the execution requirement and performs deep semantic alignment with the functional descriptions of each tool in the tool registry. The large language model ultimately outputs its decision result in a strictly structured format, such as a JSON string. This JSON string contains one or more target tool identifiers. If the large language model determines that the current subtask step can be completed without the aid of external tools, relying solely on its own parameterized knowledge, it outputs a specific no-operation identifier. This process fully leverages the zero-shot or few-shot learning capabilities of the large language model, enabling the agent to make accurate call decisions even when faced with new tools that have not been explicitly programmed, provided the tool's functional description is clear. This significantly improves the system's versatility and scalability.

[0048] 260: Obtain the corresponding interface configuration from the tool registry based on the target tool identifier, and establish a communication connection between the target agent and the execution tool to complete the mounting.

[0049] In step 260, the system performs a conversion process from logical selection to physical connection. Upon receiving the target tool identifier output by the large language model, the system's tool management middleware performs a secondary query in the backend storage of the tool registry based on the identifier to obtain the deep interface configuration information associated with that identifier. The interface configuration information includes the network transmission protocol type of the tool service, the server IP address and port number where the service resides, the authentication credentials, and the specific application layer interface path.

[0050] After obtaining the configuration, the tool management middleware uses dynamic proxy technology or reflection to instantiate a tool client stub object in the target agent's runtime sandbox environment. This client stub object encapsulates the underlying network communication details, providing a concise local method invocation interface to the target agent. At this point, a usable communication channel is established between the target agent and the remote or local execution tool, and the mounting process is officially complete. In the subsequent execution phase, the target agent only needs to pass data to this stub object according to the agreed parameter format to achieve transparent tool invocation.

[0051] The registry-based and dynamic proxy mounting method achieves complete decoupling between the core logic of the intelligent agent and the specific implementation of the tool, facilitating unlimited horizontal expansion and seamless hot updates of the tool library.

[0052] 300: Perform validity review on the output results of each target agent during execution, and execute a correction process for target agents that fail the validity review.

[0053] In the specific implementation of step 300, process monitoring and quality assessment are crucial safeguards for ensuring the reliability of the output of the multi-agent collaborative system. Due to the illusion phenomenon inherent in large language models, and the potential for contextual interference or abnormal data returned by tools during independent execution, the output often deviates from expectations. If these flawed intermediate results are passed down to downstream agents without intervention, errors will be amplified at each level, ultimately leading to the failure of the entire complex task. Therefore, step 300 introduces a rigorous closed-loop review and correction mechanism.

[0054] In an optional embodiment of step 300, the validity of the output results during the execution of each target agent is reviewed, including the following steps: 310: Obtain the output of the current subtask step and the corresponding original subtask step requirements.

[0055] In step 310, the system's review module listens for and intercepts execution completion events submitted by the target agent on the message bus. Upon capturing the event, the review module extracts the final output of the current subtask step from the event payload.

[0056] Meanwhile, the review module queries the distributed task tracking system and, based on the unique execution identifier of the current subtask step, traces back and extracts the original subtask step requirements issued to the target agent in step 200.

[0057] The original subtask steps require clearly defined input data, the expected goals, and the constraints that must be followed. The review module pairs these two sets of data in memory, preparing them for subsequent evaluation by the evaluation engine.

[0058] 320: Input the output results and original subtask step requirements into the preset review module, which will score them from three dimensions: completeness, accuracy, and logical consistency.

[0059] In step 320, the pre-built review module integrates a refined evaluation prompt word chain based on a large language model. This review module can be a standalone, lightweight large language model with strong logical judgment capabilities, specifically fine-tuned for quality assessment tasks. After receiving the paired data, the review module initiates in-depth analysis across three dimensions.

[0060] The first dimension is completeness review. The review module analyzes all the mandatory constraints and output elements extracted from the original subtask steps using a syntax tree, and checks each output result to ensure that it contains the corresponding response content. If any mandatory items are missing, completeness points are deducted proportionally based on the importance of the missing items.

[0061] The second dimension is accuracy review. Accuracy review focuses on the factual statements and data accuracy in the output. For subtasks involving numerical calculations, the review module will internally invoke a simple code interpreter to recalculate the original data and compare it with the output. For subtasks involving external knowledge, the review module may trigger a lightweight retrieval enhancement generation process to cross-validate whether key assertions in the output conflict with credible knowledge sources. If illusory content or calculation errors are found, the accuracy score will be significantly reduced.

[0062] The third dimension is logical consistency review. The review module performs logical deduction on the text structure within the output, checking for self-contradictory statements, reversed causality, or breaks in context. Simultaneously, the review module checks whether the argumentative direction of the output aligns with the core intent required by the original subtask steps, preventing irrelevant or off-topic answers. For each dimension, the review module outputs a normalized floating-point score between zero and one, along with corresponding reasons for deductions.

[0063] 330: Determine whether the overall score of the three dimensions reaches the preset passing threshold. If it does not reach the threshold, the validity review is deemed to have failed.

[0064] In step 330, the review module summarizes the integrity score, accuracy score, and logical consistency score. The system uses a weighted average algorithm to calculate the comprehensive score. Since accuracy usually has the most fatal impact on the final task quality, the weight coefficient for the accuracy score is set to the highest. The system rigorously compares the calculated comprehensive score with a preset passing threshold. The passing threshold is dynamically configured based on the fault tolerance rate of different business scenarios. If the comprehensive score is greater than or equal to the passing threshold, the review module determines that the validity review has passed and sends a release signal to the result aggregation module below. If the comprehensive score is less than the passing threshold, the review module determines that the validity review has failed and immediately freezes the downstream propagation path of the output result, triggering a correction process instead. This mechanism, which combines quantitative scoring with threshold judgment, transforms subjective quality requirements into objective and controllable engineering indicators, giving the system extremely high sensitivity and accuracy in intercepting abnormal results.

[0065] In another optional embodiment of step 300, a correction process is performed on the target agent that fails the validity review, including the following steps: 340: Send the reason for the failure of the review and the current output result to the target agent.

[0066] In step 340, the system constructs a correction request message containing detailed diagnostic information. This message not only includes the original text of the currently defective output, but more importantly, it includes the specific deduction reason text generated in step 320. To improve the agent's ability to perceive errors, the system displays the deduction reasons in a structured classification according to three dimensions, clearly indicating which specific constraint point was not met or which statement contains a factual error.

[0067] The system uses an asynchronous message queue to redirect the correction request message back to the input buffer of the target agent that produced the output result, forcibly suspending the agent's subsequent task flow and causing it to re-enter a special working state focused on error correction.

[0068] 350: Triggers a reflection prompt word within the target AI, enabling the target AI to generate an error analysis report and correction strategy based on the reasons for failure.

[0069] In step 350, after the target agent receives the correction request, its internal prompt word manager dynamically replaces the currently active system prompt word and loads a dedicated reflection prompt word template. This reflection prompt word is carefully designed to stimulate the self-correction ability of the large language model. The reflection prompt word instructs the large language model to temporarily break away from the inertia of continuing to execute the task and instead, from the perspective of a rigorous code reviewer or quality expert, re-examine the current output results and the reasons for failure.

[0070] Guided by reflective prompts, the large language model executes a thought chain reasoning process. First, it recreates the reasoning path that led to the erroneous conclusion in its internal representation space, locating the specific node where the deviation occurred, such as misunderstanding a certain context or passing incorrect parameters when calling the tool.

[0071] Based on the localization results, the large language model generates a formatted error analysis report, detailing the root cause of the error. Following this, the large language model formulates actionable corrective strategies based on the error analysis report.

[0072] The correction strategy clearly defines the type of correction action, such as whether it is necessary to call external tools again to obtain the correct data, whether it is necessary to adjust the internal reasoning logic and regenerate the text, or whether it is necessary to adjust the output format to meet the integrity requirements.

[0073] The internalized reflection mechanism transforms the intelligent agent from a black box that can only output in one direction into a metacognitive ability similar to that of human experts who pause to think and adjust their plans after discovering errors.

[0074] 360: Control the target agent to re-execute the current subtask steps according to the correction strategy, and count the number of retries.

[0075] In step 360, the system's process control engine parses the correction strategy generated by the target agent and translates it into specific execution instructions. If the correction strategy indicates that the tool needs to be invoked again, the process control engine resets the tool invocation state machine, allowing the target agent to initiate the tool invocation request again with the corrected parameters.

[0076] If the correction strategy indicates that the text needs to be regenerated, the flow control engine clears the current output buffer and forces the large language model to regenerate the text based on the new cognitive state through autoregressive decoding.

[0077] Optionally, during the re-execution of the target agent, the system maintains a retry counter in a distributed cache, which is bound to the current subtask step identifier. The counter is incremented by one each time a reflexive re-execution is triggered.

[0078] The retry counter is introduced to prevent the system from falling into an infinite reflection loop caused by the inherent flaws of large language models. By setting a clear upper limit on the number of retries, the system gives the agent a chance to self-correct while also retaining bottom-line control capabilities, ensuring that computing resources are not endlessly consumed on unsolvable problems.

[0079] In this optional embodiment, after counting the number of retries, the following steps are also included: 361: Determine whether the number of retries has reached the preset maximum number of retries and the validity review has still failed.

[0080] In step 361, after the target agent completes a re-execution of the corrected strategy, the system automatically sends the newly generated output result back to the validity review process in steps 310 to 330. If the review passes, the retry counter is reset to zero, and the process proceeds normally. If the review still fails, the system extracts the current retry count and compares it with the preset maximum number of retries. The maximum number of retries is usually set to a small odd number, such as three, based on the time sensitivity of the task and the resource budget.

[0081] When the judgment indicates that the maximum number of retries has been reached, and the latest output still fails the validity check, it means that relying solely on the target agent's own reflection and recalculation capabilities is insufficient to overcome the current obstacles. These obstacles may stem from deep-seated contradictions in the original instructions themselves, persistent malfunctions in external tools, or extremely complex problems exceeding the cognitive capabilities of the current large language model. In this case, the system must abandon the automatic repair path and switch to a manual intervention mechanism.

[0082] 362: If the target is reached, pause the current task flow and generate a visual intervention page containing the current execution progress, historical output results, and reasons for failure, and send it to the user.

[0083] In step 362, the system performs a process freeze operation under emergency conditions. The process control engine broadcasts a task pause command to the message bus, and all related agents that are running or in a queue are placed in a suspended state to prevent further state contamination. Subsequently, the system's front-end rendering service is triggered to collect the full-link execution context information of the current task. This information includes the overall task's macro progress indication, the number of the currently stuck subtask step, the set of output results of all previously approved subtask steps, a comparison of the output results of each attempt of the currently failed subtask step, and a summary of detailed failure reasons given by the review module each time.

[0084] The system uses this information to dynamically construct a clearly structured and focused visual intervention page. Optionally, this page uses different color labels to distinguish the importance of information; for example, red highlights the reasons for failure, and green marks successful steps. The system pushes this visual intervention page to the user's client interface in real time via WebSocket long-connection technology or server-side event sending technology. This step completely breaks the deadlock dilemma that fully automated systems are prone to when facing unsolvable problems. By establishing a transparent human-computer interaction interface, complex underlying technical errors are transformed into business-level decision choices that users can understand, greatly improving the robustness and availability of complex systems in real production environments.

[0085] 363: Receive manual adjustment instructions from users on the visual intervention page, and update the current subtask steps or re-match the target agent based on the manual adjustment instructions.

[0086] In step 363, the system monitors user interactions with the visual intervention page on the front end. Based on the detailed context provided by the system, users can make manual intervention decisions across multiple dimensions. The system parses and categorizes the user's manual adjustment instructions. If the user determines that the failure is due to unreasonable requirements in the current subtask step, the user can manually edit and modify the original requirements or constraints of that subtask step. Upon receiving the modified instructions, the system updates the instruction data in the task state machine and wakes up the original target agent to re-execute based on the new instructions.

[0087] If the user determines that the failure is due to a mismatch in the capabilities of the assigned target agent, such as incorrectly assigning a complex mathematical reasoning task to an agent skilled in text writing and failing to resolve the issue after multiple attempts, the user can manually specify on the intervention page to replace it with a coding integration development environment expert or directly trigger the re-matching process. The system will discard the execution context of the original target agent, call the logic of steps 210 to 230 to reselect the most suitable candidate agent for the subtask step, and start execution.

[0088] If the user determines that a subtask step is impossible to complete, they can choose to skip it or terminate the entire task. Upon receiving a manual adjustment instruction, the system automatically restores the task flow state machine and continues progressing along the user-specified correction direction. This manual intervention mechanism grants the user the highest level of control over the multi-agent system, achieving a perfect synergy between machine intelligence and human wisdom. This ensures that even in extreme boundary situations, the system can still provide a final response that meets the user's actual business needs.

[0089] 400: The execution results of each subtask step are trimmed, deduplicated, and logically linked, and then aggregated into a final result as the output to the user.

[0090] In a specific implementation of step 400, result aggregation and delivery is the final stage of multi-agent collaborative processing of complex tasks. After the preceding task decomposition, parallel or serial collaborative execution by multiple agents, and rigorous quality review and correction, the system often possesses a collection of fragmented information produced by multiple different agents, with varying formats, different focuses, and a large amount of intermediate inference noise. If this fragmented information is simply physically pieced together and presented directly to the user, it will lead to information overload, greatly increasing the user's cognitive burden and significantly diminishing the efficiency gains brought by the multi-agent system in the final delivery stage. Therefore, step 400 performs deep semantic-level processing on the fragmented information, transforming it into a final deliverable with high information density, high readability, and logical consistency.

[0091] In an optional embodiment, step 400 further includes the following steps: 410: According to the execution sequence of the subtask steps, extract the core conclusion paragraphs from each execution result and remove redundant reasoning process information to complete the trimming.

[0092] In step 410, the system first reconstructs the actual execution sequence of each subtask step within the macro-task blueprint based on the timestamps and dependency graphs recorded in the distributed task tracing system. Subsequently, the system initiates a pruning operation for the execution results of each approved subtask step. This is because, during execution, especially when generating content using a large language model, the agent often outputs a large amount of thought chain derivation processes, restatements of background knowledge, and transitional explanatory statements. This information is purely redundant for users who already have a clear understanding of the task background.

[0093] The system employs an information entropy-based text trimming algorithm or a specially trained text summarization extraction model to scan the execution results paragraph by paragraph. The algorithm calculates the information density index of each paragraph, identifying paragraphs containing final conclusions, core data indicators, key code snippets, or decisive judgments, and marking them as core conclusion paragraphs. Transitional sentences and paragraphs containing obvious procedural characteristics, such as "Let's think about it," "Based on the above analysis," or "The first step we need," as well as redundant sentences that repeatedly emphasize the same viewpoint, are marked as content to be removed.

[0094] By performing a pruning operation, the system significantly reduces the text size output by each subtask step, retaining the most valuable essential information and reducing computational complexity for subsequent integration processing.

[0095] 420: Cross-compare the execution results of each subtask step, identify and delete semantically duplicated data entities in each execution result to complete deduplication.

[0096] In step 420, different agents may obtain information describing the same objective fact or entity from different perspectives or data sources when performing interconnected sub-tasks. For example, the online search agent obtains a company's annual revenue data in step A, while the data query agent retrieves the exact same revenue data from its internal database in step B. If this is not removed, duplicate data statements will appear in the final result.

[0097] The system employs cross-text semantic entity alignment and deduplication techniques. First, the system uses named entity recognition technology to extract all data entities and noun-based concept entities from the core conclusion paragraphs of each execution result. Next, the system maps the extracted entities into dense vector representations and constructs an entity similarity matrix among the execution result sets of different subtask steps.

[0098] For entity pairs whose vector space distance is less than a preset threshold and whose entity types are consistent, the system determines them to be semantically duplicated data entities. After identifying duplicate entities, the system does not simply perform physical deletion, but rather evaluates the relevance of the context and retains the entity representation that is in the most suitable logical context. In other execution results, the duplicate entity is replaced with a retroflex pronoun or directly removed from the sentence, while the grammatical structure of the sentence is adjusted to ensure the fluency of the statement.

[0099] By performing deep semantic-level deduplication, information redundancy in the multi-source information fusion process is effectively eliminated, ensuring the conciseness of the final output.

[0100] 430: Construct logical transition statements between the core conclusion paragraphs in each execution result, and splice the deduplicated core conclusion paragraphs to form a coherent intermediate text.

[0101] In step 430, the system addresses the issue of awkwardness when splicing fragmented information. While the core conclusion paragraphs, after trimming and deduplication, are accurate and concise, direct splicing leads to a lack of text coherence and obvious machine assembly artifacts. The system introduces discourse generation and coreference resolution techniques. Based on the execution sequence restored in step 410, the system analyzes the logical relationships between adjacent core conclusion paragraphs. These logical relationships include causal, progressive, adversative, parallel, or general-to-specific relationships.

[0102] Based on the identified logical relationship attributes, the system calls a pre-set library of logical transition phrase templates to generate appropriate logical transition statements. For example, if the conclusion of the preceding paragraph is a cause and the conclusion of the following paragraph is a result, the system inserts a transition statement indicating a causal relationship.

[0103] At the same time, the system performs a global coreference resolution operation to identify pronouns or noun phrases that refer to the same object in different paragraphs, unify their expression, and avoid causing ambiguity for users.

[0104] Finally, the system uses logical transitional statements as a glue to rigorously splice together the deduplicated core conclusion paragraphs according to chronological order and logical topology, generating a fluent, coherent, and rigorously argued intermediate text. This intermediate text already possesses the rudiments of a high-quality report or document, achieving a qualitative leap from discrete output by multiple agents to a unified and coherent semantic whole.

[0105] After generating the intermediate text, the system performs final layout and formatting according to the expected output format specified by the user when confirming the standardization instructions in step 100. If the user requests a plain text summary, the intermediate text is output directly; if the user requests a structured report, the system further utilizes a large language model to generate hierarchical headings, emphasis bolding, and bulleted lists for the intermediate text; if the user requests a data file in a specific format, the system extracts the core data entities from the intermediate text and fills them into the table template.

[0106] The final formatted result is officially delivered to the user through the system's user interface, marking the perfect closed loop of the entire system process for multi-agent collaboration to complete complex tasks.

[0107] Through the trimming, deduplication, and logical concatenation aggregation mechanisms detailed in step 400, this application completely overcomes the inherent problems of fragmented, redundant, and poorly readable output results in traditional multi-module concatenated systems. It provides users with a one-stop, high-value intelligent service experience, fully demonstrating the superior advantages and significant industrial application value of multi-agent systems in handling complex business processes.

[0108] The multi-agent task processing method in the embodiments of the present invention has been described above. The multi-agent task processing apparatus in the embodiments of the present invention is described below. Please refer to [link / reference]. Figure 2 One embodiment of the multi-agent task processing device in this invention includes: The receiving module 001 is used to receive user requests and clarify the user requests with unclear clarity through interactive inquiry and feedback loops. After the clarity of the user requests meets the preset clarity conditions, it generates standardized instructions based on the user requests and confirms them with the user.

[0109] The matching module 002 is used to decompose the standardized instructions into at least one sub-task step, and match a corresponding target intelligent agent for each sub-task step from a preset intelligent agent resource pool; the target intelligent agent is used to execute each of the corresponding sub-task steps, and during the execution process, the corresponding execution tool is dynamically attached and called according to the professional capabilities of the target intelligent agent.

[0110] The review module 003 is used to review the validity of the output results of each target intelligent agent during the execution process, and to perform a correction process for the target intelligent agents that fail the validity review.

[0111] The processing module 004 is used to trim, deduplicatize, and logically concatenate the execution results of each of the subtask steps, and aggregate them into a final result as output to the user.

[0112] The matching module 002 is further used to extract the professional skill tags and tool preference tags required for the current subtask step; traverse the capability profiles of each candidate agent in the agent resource pool, the capability profiles including historical execution success rates and areas of expertise; calculate the matching degree score between the professional skill tags, tool preference tags and the capability profiles of each candidate agent, and determine the candidate agent with the highest matching degree score as the target agent.

[0113] The matching module 002 is further configured to, when the target agent begins to execute the sub-task step, read a pre-configured tool registry, which stores a mapping relationship between tool identifiers and function descriptions; input the execution requirements of the sub-task step into the large language model of the target agent, and have the large language model output the target tool identifier to be called; obtain the corresponding interface configuration from the tool registry according to the target tool identifier, and establish a communication connection between the target agent and the execution tool to complete the mounting.

[0114] The review module 003 is further used to obtain the output result of the current subtask step and the corresponding original subtask step requirements; input the output result and the original subtask step requirements into the preset review module, which scores them from three dimensions: completeness, accuracy and logical consistency; determine whether the comprehensive score of the three dimensions reaches the preset passing threshold, and if it does not reach the threshold, the validity review is determined to be unsuccessful.

[0115] The review module 003 is also used to send the reason for the review failure and the current output result to the target intelligent agent; trigger the reflection prompt words inside the target intelligent agent, so that the target intelligent agent generates an error analysis report and correction strategy based on the reason for failure; control the target intelligent agent to re-execute the current sub-task steps according to the correction strategy, and count the number of retries.

[0116] After counting the number of retries, the review module 003 is also used to: determine whether the number of retries has reached the preset maximum number of retries and the validity review has still failed; if it has, then pause the current task process and generate a visual intervention page containing the current execution progress, historical output results and failure reasons and send it to the user; receive the manual adjustment instructions entered by the user on the visual intervention page, and update the current subtask steps or re-match the target agent according to the manual adjustment instructions.

[0117] The processing module 004 is further configured to extract the core conclusion paragraphs from each execution result according to the execution sequence of the sub-task steps, remove redundant reasoning process information to complete the trimming; cross-compare the execution results of each sub-task step, identify and delete semantically repetitive data entities in each execution result to complete deduplication; construct logical transition statements between each core conclusion paragraph in each execution result, and splice the deduplicated core conclusion paragraphs to form a coherent intermediate text.

[0118] above Figure 2 The multi-agent task processing device in this embodiment of the invention is described in detail from the perspective of modular functional entities. The computer device in this embodiment of the invention is described in detail below from the perspective of hardware processing.

[0119] Figure 3This is a schematic diagram of the structure of a computer device 500 provided in an embodiment of the present invention. The computer device 500 can vary significantly due to different configurations or performance characteristics. It may include one or more central processing units (CPUs) 510 (e.g., one or more processors) and a memory 520, and one or more storage media 530 (e.g., one or more mass storage devices) for storing application programs 533 or data 532. The memory 520 and storage media 530 can be temporary or persistent storage. The program stored in the storage media 530 may include one or more modules (not shown in the diagram), each module including a series of instruction operations on the computer device 500. Furthermore, the processor 510 may be configured to communicate with the storage media 530 and execute the series of instruction operations in the storage media 530 on the computer device 500.

[0120] Computer device 500 may also include one or more power supplies 540, one or more wired or wireless network interfaces 550, one or more input / output interfaces 560, and / or one or more operating systems 531, such as Windows Server, Mac OSX, Unix, Linux, FreeBSD, etc. Those skilled in the art will understand that... Figure 3 The computer device structure shown does not constitute a limitation on the computer device and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0121] This application also provides a computer device, which includes a memory and a processor. The memory stores computer-readable instructions. When the computer-readable instructions are executed by the processor, the processor performs the steps of the multi-agent task processing method in the above embodiments.

[0122] This application also provides a computer-readable storage medium, which can be a non-volatile computer-readable storage medium or a volatile computer-readable storage medium. The computer-readable storage medium stores instructions that, when executed on a computer, cause the computer to perform the steps of a multi-agent task processing method.

[0123] Unlike existing technologies, this application proposes a method for multi-agent collaboration to complete complex tasks. By adopting a divide-and-conquer strategy, it solves the problems of limited capabilities and poor scalability of a single agent, and achieves significant technical effects through collaboration.

[0124] First, an interactive query and feedback loop technique is employed. Upon receiving a request, the system calculates a clarity score, generates guiding questions for ambiguous needs, and continues until preset conditions are met, at which point a standardized instruction is generated and confirmed with the user. This eliminates ambiguity in business requirements from the outset, ensures the accuracy of input instructions, and significantly reduces the rework rate downstream due to misunderstandings.

[0125] Secondly, the system employs agent matching and dynamic tool mounting techniques based on multi-dimensional tags and capability profiles. The system extracts professional skill tags and tool preference tags from sub-tasks, and combines these with the historical execution success rate and domain expertise of candidate agents to calculate a matching score, thus achieving optimal agent selection. Simultaneously, by reading the tool registry and using a large language model to infer and output target tool identifiers, communication connections are established on demand via dynamic proxies. This achieves precise matching of computing resources and task requirements, breaking the inherent capability boundaries of agents and greatly improving the system's flexibility and scalability.

[0126] Furthermore, a multi-dimensional validity review and tiered correction technique is employed. The review module quantifies and scores the output results from three dimensions: completeness, accuracy, and logical consistency. If the score fails to meet the threshold, the agent triggers self-correction and retry based on reflection prompts. If the retry limit is exceeded, the process is paused, and a visual intervention page containing the reasons for failure is generated for the user to manually adjust. This robust error interception defense effectively suppresses the illusion of large language models and error cascading. Combined with machine self-healing and manual fallback, it significantly enhances the robustness and controllability of complex task execution.

[0127] Finally, information aggregation techniques involving pruning, deduplication, and logical concatenation are employed. The system eliminates redundant reasoning processes according to execution sequence, identifies and removes duplicate data entities through cross-text semantic entity alignment, and then constructs logical transition statements to form coherent intermediate text. This transforms fragmented information generated by multiple agents into a high-information-density, logically consistent final result, completely solving the problems of information overload and awkward splicing, and greatly optimizing the final delivery quality and user experience.

[0128] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to interchangeably. Each embodiment focuses on its differences from other embodiments. In particular, the storage medium embodiments and computer device embodiments are basically similar to the method embodiments, so the descriptions are relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0129] This application can be used in a wide range of general-purpose or special-purpose computing system environments or configurations. For example: personal computers, handheld or portable devices, tablet devices, multiprocessor systems, microprocessor-based systems, network PCs, minicomputers, distributed computing environments including any of the above systems or devices, etc.

[0130] In the several embodiments provided in this application, it should be understood that the disclosed methods and devices can be implemented in other ways. For example, the device embodiments described above are merely illustrative; multiple units or components may be combined or integrated into another system, or some features may be omitted or not performed.

[0131] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment, depending on actual needs.

[0132] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0133] The above description is merely an embodiment of this application and does not limit the patent scope of this application. Any equivalent structural or procedural transformations made using the content of this application's specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent protection scope of this application.

Claims

1. A multi-agent task processing method, characterized in that, include: The system receives user requests and clarifies unclear user requests through interactive questioning and feedback loops until the clarity of the user request meets the preset clarity conditions. Then, it generates standardized instructions based on the user request and confirms them with the user. The standardized instructions are decomposed into at least one sub-task step, and a corresponding target intelligent agent is matched for each sub-task step from a pre-set intelligent agent resource pool; the target intelligent agent is used to execute each of the corresponding sub-task steps, and during the execution process, the corresponding execution tools are dynamically attached and called according to the professional capabilities of the target intelligent agent. The output results of each target intelligent agent during the execution process are reviewed for validity, and a correction process is executed for the target intelligent agents that fail the validity review; The execution results of each subtask step are pruned, deduplicated, and logically concatenated, and then aggregated into a final result as the output to the user.

2. The multi-agent task processing method according to claim 1, characterized in that, The step of matching a target agent for each subtask step from a pre-set agent resource pool includes: Extract the professional skill tags and tool preference tags required for the current subtask step; Iterate through the capability profiles of each candidate intelligent agent in the intelligent agent resource pool. The capability profiles include historical execution success rates and areas of expertise. Calculate the matching score between the professional skill tags, tool preference tags and the ability profiles of each candidate agent, and determine the candidate agent with the highest matching score as the target agent.

3. The multi-agent task processing method according to claim 1, characterized in that, The step of dynamically mounting and invoking corresponding execution tools based on the professional capabilities of the target intelligent agent includes: When the target agent begins to execute the sub-task step, a pre-configured tool registry is read, which stores the mapping relationship between tool identifiers and function descriptions; The execution requirements of the sub-task steps are input into the large language model of the target agent, and the large language model outputs the target tool identifier to be called. Based on the target tool identifier, the corresponding interface configuration is obtained from the tool registry, and a communication connection is established between the target agent and the execution tool to complete the mounting.

4. The multi-agent task processing method according to claim 1, characterized in that, The validity review of the output results during the execution process of each target intelligent agent includes: Obtain the output result of the current subtask step and the corresponding original subtask step requirements; The output results and the original subtask steps are input into a preset review module, which scores the results based on three dimensions: completeness, accuracy, and logical consistency. Determine whether the overall score of the three dimensions reaches the preset passing threshold. If it does not, the validity review is deemed to have failed.

5. The multi-agent task processing method according to claim 1, characterized in that, The process of performing a correction procedure on the target agent that fails the validity review includes: Send the reason for the failure of the review and the current output result to the target intelligent agent; Trigger reflection prompts within the target intelligent agent, enabling it to generate an error analysis report and correction strategy based on the reasons for failure; The target agent is controlled to re-execute the current subtask steps according to the correction strategy, and the number of retries is counted.

6. The multi-agent task processing method according to claim 5, characterized in that, Following the count of retries, the following is also included: Determine whether the number of retries has reached the preset maximum number of retries and the validity check still fails; If the target is reached, the current task flow will be paused, and a visual intervention page containing the current execution progress, historical output results, and reasons for failure will be generated and sent to the user. Receive manual adjustment instructions input by the user on the visual intervention page, and update the current subtask step or re-match the target agent according to the manual adjustment instructions.

7. The multi-agent task processing method according to claim 1, characterized in that, The process of pruning, deduplicating, and logically concatenating the execution results of each subtask step includes: According to the execution sequence of the sub-task steps, extract the core conclusion paragraphs from each execution result and remove redundant reasoning process information to complete the trimming; The execution results of each subtask step are cross-compared to identify and delete semantically duplicated data entities in each execution result to complete deduplication; Construct logical transition statements between the core conclusion paragraphs in each execution result, and then concatenate the deduplicated core conclusion paragraphs to form a coherent intermediate text.

8. A multi-agent task processing apparatus, used in the multi-agent task processing method as described in any one of claims 1-7, characterized in that, include: The receiving module is used to receive user requests and clarify the user requests with unclear clarity through interactive questioning and feedback loops. After the clarity of the user requests meets the preset clarity conditions, the module generates standardized instructions based on the user requests and confirms them with the user. The matching module is used to decompose the standardized instructions into at least one sub-task step, and match a corresponding target intelligent agent for each sub-task step from a preset intelligent agent resource pool; the target intelligent agent is used to execute each of the corresponding sub-task steps, and during the execution process, the corresponding execution tool is dynamically attached and called according to the professional capabilities of the target intelligent agent. The review module is used to review the validity of the output results of each target intelligent agent during the execution process, and to perform a correction process for the target intelligent agents that fail the validity review. The processing module is used to trim, deduplicatize, and logically concatenate the execution results of each subtask step, and aggregate them into a final result as output to the user.

9. A computer device, characterized in that, The computer device includes: a memory and at least one processor, wherein the memory stores instructions; The at least one processor invokes the instructions in the memory to cause the computer device to perform the multi-agent task processing method as described in any one of claims 1-7.

10. A computer-readable storage medium storing instructions thereon, characterized in that, When the instructions are executed by the processor, they implement the multi-agent task processing method as described in any one of claims 1-7.

Images