A task processing method, system, device and equipment

Abstract

This specification discloses a task processing method, system, apparatus, and device. The method includes: acquiring sub-tasks corresponding to user demand information input by a target user, as well as the dependencies between different sub-tasks; then, invoking an agent management subsystem and, based on the capability evaluation information of each agent in the agent subsystem provided by the agent management subsystem, determining the agent information to execute each sub-task according to the sub-tasks corresponding to the user demand information; subsequently, executing the sub-tasks sequentially through the corresponding agents according to the agent information to execute each sub-task and the dependencies between different sub-tasks, obtaining corresponding execution results; and finally, generating and outputting a response result corresponding to the user demand information based on the obtained execution results.

Description

Technical Field

[0001] This document relates to the field of computer technology, and in particular to a method, system, apparatus, and device for processing a task. Background Technology

[0002] As artificial intelligence technology permeates work and life scenarios, single-function intelligent tools (such as AI document generation, intelligent reminders, and data statistics tools) have gradually become widespread. However, they still fall short of meeting users' needs for "full automation of complex work processes." Therefore, there is a need to provide an interactive mechanism that enables multi-agent collaboration, covers the entire complex work process, and has data interoperability, in order to improve the level of intelligence and user work efficiency in work and life scenarios. Summary of the Invention

[0003] The purpose of the embodiments in this specification is to provide an interactive mechanism that enables multi-agent collaboration, covers the entire complex work process, and has data interoperability, so as to improve the level of intelligence and user work efficiency in work and life scenarios.

[0004] To achieve the above technical solution, the embodiments in this specification are implemented as follows: This specification provides a task processing method applied to an intelligent agent subsystem. The method includes: acquiring subtasks corresponding to user demand information input by a target user, and the dependencies between different subtasks; invoking an intelligent agent management subsystem, and based on the capability evaluation information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determining the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information; executing the subtasks sequentially through the corresponding intelligent agents according to the intelligent agent information executing each subtask and the dependencies between different subtasks, obtaining corresponding execution results; and generating and outputting a response result corresponding to the user demand information based on the obtained execution results.

[0005] This specification provides a task processing system comprising a user interaction subsystem, an agent management subsystem, and an agent subsystem. The agent management subsystem is configured to: evaluate the capabilities of each agent within the agent subsystem and determine capability evaluation information for each agent; receive user request information input by a target user, parse the user request information, determine the subtasks corresponding to the user request information, and the dependencies between different subtasks; obtain the subtasks corresponding to the user request information input by the target user, and the dependencies between different subtasks, from the user interaction subsystem; invoke the agent management subsystem, and based on the capability evaluation information of each agent within the agent subsystem provided by the agent management subsystem, determine the agent information to execute each subtask according to the subtasks corresponding to the user request information; execute the subtasks sequentially through the corresponding agents according to the agent information executing each subtask and the dependencies between different subtasks, obtaining corresponding execution results; and generate and output a response result corresponding to the user request information based on the obtained execution results.

[0006] This specification provides a task processing method applied to a coordination and scheduling subsystem. The method includes: acquiring subtasks corresponding to user demand information input by a target user, and the dependencies between different subtasks; invoking an agent management subsystem, and based on the capability evaluation information of each agent in the agent subsystem provided by the agent management subsystem, determining the agent information to execute each subtask according to the subtasks corresponding to the user demand information; sequentially invoking the corresponding agents in the agent subsystem to execute the subtasks according to the agent information executing each subtask and the dependencies between different subtasks, obtaining corresponding execution results; and generating and outputting a response result corresponding to the user demand information based on the obtained execution results.

[0007] This specification provides a task processing system, comprising a user interaction subsystem, an agent management subsystem, a collaborative scheduling subsystem, and an agent subsystem. The agent subsystem includes various agents. Specifically: the agent management subsystem is configured to evaluate the capabilities of each agent within the agent subsystem and determine the capability evaluation information of each agent; the user interaction subsystem is configured to receive user request information input by a target user, parse the user request information, determine the subtasks corresponding to the user request information, and the dependencies between different subtasks; the collaborative scheduling subsystem is configured to... The system is configured to obtain subtasks corresponding to user demand information input by the target user from the user interaction subsystem, as well as the dependencies between different subtasks; invoke the agent management subsystem, and based on the capability evaluation information of each agent in the agent subsystem provided by the agent management subsystem, determine the agent information to execute each subtask according to the subtask corresponding to the user demand information; according to the agent information to execute each subtask and the dependencies between different subtasks, sequentially invoke the corresponding agents in the agent subsystem to execute the subtasks, and obtain the corresponding execution results; based on the obtained execution results, generate and output the response result corresponding to the user demand information.

[0008] This specification provides a task processing apparatus, comprising: a task acquisition module for acquiring sub-tasks corresponding to user demand information input by a target user, and the dependencies between different sub-tasks; a task and agent matching module for invoking an agent management subsystem and, based on the capability evaluation information of each agent in the agent subsystem provided by the agent management subsystem, determining the agent information for executing each sub-task according to the sub-tasks corresponding to the user demand information; a task execution module for sequentially executing the sub-tasks through the corresponding agents according to the agent information for executing each sub-task and the dependencies between different sub-tasks, obtaining corresponding execution results; and a demand response module for generating and outputting a response result corresponding to the user demand information based on the obtained execution results.

[0009] This specification provides an embodiment of a task processing device, comprising: a processor; and a memory configured to store computer-executable instructions, wherein, when executed, the processor: acquires subtasks corresponding to user demand information input by a target user, and the dependencies between different subtasks; invokes an agent management subsystem, and based on the capability assessment information of each agent in the agent subsystem provided by the agent management subsystem, determines the agent information for executing each subtask according to the subtasks corresponding to the user demand information; executes the subtasks sequentially through the corresponding agents according to the agent information for executing each subtask and the dependencies between different subtasks, and obtains corresponding execution results; and generates and outputs a response result corresponding to the user demand information based on the obtained execution results.

[0010] This specification also provides a storage medium for storing computer-executable instructions. When executed by a processor, these instructions implement the following process: obtaining subtasks corresponding to user demand information input by a target user, and the dependencies between different subtasks; invoking an agent management subsystem, and based on the capability evaluation information of each agent in the agent subsystem provided by the agent management subsystem, determining the agent information for executing each subtask according to the subtasks corresponding to the user demand information; executing the subtasks sequentially through the corresponding agents according to the agent information for executing each subtask and the dependencies between different subtasks, obtaining corresponding execution results; and generating and outputting a response result corresponding to the user demand information based on the obtained execution results.

[0011] This specification also provides a computer program product, including a computer program that, when executed by a processor, implements the following process: obtaining subtasks corresponding to user demand information input by a target user, and the dependencies between different subtasks; invoking an agent management subsystem, and based on the capability evaluation information of each agent in the agent subsystem provided by the agent management subsystem, determining the agent information to execute each subtask according to the subtasks corresponding to the user demand information; executing the subtasks sequentially through the corresponding agents according to the agent information executing each subtask and the dependencies between different subtasks, obtaining corresponding execution results; and generating and outputting a response result corresponding to the user demand information based on the obtained execution results. Attached Figure Description

[0012] To more clearly illustrate the technical solutions in the embodiments or prior art of this specification, the drawings used in the description of the embodiments or prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. Figure 1 This is a schematic diagram of the structure of a task processing system according to this specification; Figure 2 This is a schematic diagram of the structure of a system for processing another task in this specification; Figure 3 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 4 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 5 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 6 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 7 This is a schematic diagram illustrating the processing procedure of one task in this specification; Figure 8 This is a schematic diagram illustrating the processing procedure for another task described in this manual; Figure 9 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 10 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 11 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 12 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 13 This is a schematic diagram of the structure of another task processing system described in this specification; Figure 14 This is a schematic diagram illustrating the processing procedure for yet another task described in this manual. Figure 15 This is a schematic diagram illustrating the processing procedure for yet another task described in this manual. Figure 16 This is a schematic diagram of a task processing device according to this specification; Figure 17 This is a schematic diagram of a task processing device according to this specification. Detailed Implementation

[0013] This specification provides a method, system, apparatus, and device for processing tasks.

[0014] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this specification, and not all embodiments. Based on the embodiments in this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this specification.

[0015] This specification provides an interactive mechanism for multi-agent collaborative business processing. With the penetration of artificial intelligence technology into work and life scenarios, single-function intelligent tools (such as AI document generation, intelligent reminders, and data statistics tools) have gradually become widespread. However, they still struggle to meet users' needs for "fully automated complex work processes." Currently, there are some similar technical solutions. For example, within a certain software ecosystem, AI functions across software can call tools within that software to complete certain data processing tasks, demonstrating some tool linkage capabilities. However, this method lacks autonomous task decomposition capabilities, requiring users to manually trigger specific functions in each software. It cannot automatically decompose the complex requirement of "generating a report and synchronizing it to the team platform" into sub-tasks such as "data statistics → document generation → file synchronization." Moreover, the scope of collaboration is limited, as it only covers a specific software ecosystem and cannot link synchronization or reminder functions of third-party platforms. Cross-platform collaboration requires manual user operation. Furthermore, data sharing is weak; various tools only share data to a limited extent within the software ecosystem, failing to obtain user information such as team member information and folder paths on third-party platforms, requiring users to repeatedly input this data. In addition to the methods mentioned above, integration into office collaboration platforms is also an option. The specific handling is similar to that described above, and will not be elaborated upon here. In summary, the current processing methods are costly. Most current smart tools operate independently, requiring users to manually switch between multiple tools and repeatedly input information (such as repeatedly uploading weekly report files and manually entering member contact information) when handling complex tasks (e.g., generating project weekly reports → synchronizing to the team platform → reminding members to review). This cumbersome process is further compounded by poor task adaptability. A single tool can only handle specific task types (e.g., document tools can only generate reports, and synchronization tools can only transfer files), failing to cover cross-domain complex scenarios involving data extraction, content generation, platform synchronization, and personnel collaboration, requiring users to manually connect each step. Furthermore, data interoperability is weak. Each tool stores data independently, making it impossible to share information such as user work habits and task progress (e.g., the reminder tool cannot obtain the report generation status from the document tool, requiring users to manually indicate "report completed"), easily leading to inconsistencies or duplicate processing. Finally, fault tolerance is insufficient. If a tool fails (e.g., the interface times out during file synchronization), users must manually troubleshoot and re-operate, lacking an automatic mechanism to switch to alternative tools or resume execution, impacting task processing efficiency. Against this backdrop, there is an urgent need for an interactive mechanism that enables multi-agent collaboration, covers the entire complex work process, and possesses data interoperability and fault tolerance capabilities, in order to improve the level of intelligence and user work efficiency in work and life scenarios. This specification provides an achievable technical solution through its embodiments; specific processing details can be found in the following embodiments.

[0016] The task processing system provided in one or more embodiments of this specification is applicable to the implementation environment of task processing. (Refer to...) Figure 1The system includes a user interaction subsystem 100, an intelligent agent management subsystem 200, and an intelligent agent subsystem 300, wherein: The user interaction subsystem 100 can include input boxes for one or more of the following: text, voice, and image. Users can input one or more of these data through these input boxes. Furthermore, the user interaction subsystem 100 can also perform user requirement analysis and task decomposition functions to analyze and break down complex user tasks. Task decomposition can involve breaking down compound or complex user requirements (such as "generate a report + synchronize report files + submit for approval") into several independently executable subtasks, clearly defining the goal, input data, output data, and execution priority of each subtask.

[0017] The agent management subsystem 200 can be used to record and manage different agents in the agent subsystem 300. This can include evaluating the capabilities of each agent and recording the attribute information of different agents. Furthermore, to better evaluate the capabilities of each agent, corresponding algorithms or models can be set in the agent management subsystem 200. In this embodiment, an agent can refer to an artificial intelligence program with specific functions that can autonomously execute preset tasks. An agent can receive instructions, process data, and provide feedback results. In practical applications, different types or functions of agents can be set up according to the different functions to be implemented, such as document processing agents, data extraction agents, and platform synchronization agents. In this embodiment, different agents belong to a single user and have data interaction and task collaboration capabilities.

[0018] The intelligent agent subsystem 300 can include various intelligent agents. The number and type of intelligent agents can be set according to the actual task (or the sub-tasks mentioned above). For example, for a sub-task of "data extraction + report generation", a data extraction intelligent agent and a document processing intelligent agent can be set up. For a sub-task of "submit for approval", a reminder intelligent agent can be set up to remind the relevant approvers to process the approval. The intelligent agent subsystem 300 can schedule the corresponding intelligent agents to execute the sub-task according to the specific sub-task content.

[0019] In practical applications, the agent management subsystem 200 is configured to evaluate the capabilities of each agent in the agent subsystem 300 and determine the capability evaluation information of each agent in the agent subsystem 300.

[0020] In implementation, the agent management subsystem 200 can include an agent capability assessment model. This model can be constructed in various ways, such as using a specified neural network, a specified algorithm, or a large model (e.g., a large language model), depending on the specific requirements. The agent capability assessment model allows for capability evaluation of each agent in the agent subsystem 300, obtaining and recording the assessment information for each agent. Furthermore, the agent management subsystem 200 can be configured with specified algorithms or models to acquire and store the attribute information of each agent. Additionally, other modules or units can be added to the agent management subsystem 200 as needed to implement other related agent management functions.

[0021] The user interaction subsystem 100 is configured to receive user demand information input by the target user, parse the user demand information, determine the sub-tasks corresponding to the user demand information, and the dependencies between different sub-tasks.

[0022] The target user can be any user. User requirement information can be compound or complex requirements raised by users in work or life scenarios, such as "Generate November project weekly report (including project progress, cost consumption, problem summary, etc.), synchronize it to the R&D department's SharePoint folder, extract 3 core conclusions to generate a PPT summary, and remind manager Zhao Liu to approve it before 5 PM today." In practical applications, user requirement information can also be single or simple requirement information, such as "Generate November project weekly report (including project progress, cost consumption, problem summary, etc.)," ​​etc., which can be set according to the actual situation. Subtasks can be independently executable subtasks. For example, "Generate November project weekly report (including project progress, cost consumption, problem summary, etc.)" can be a subtask, and "Synchronize the project weekly report to the R&D department's SharePoint folder" can also be a subtask, etc. The dependency relationship between different subtasks can be a one-way influence relationship between different subtasks, which can include information such as the execution priority of subtasks.

[0023] In implementation, the user interaction subsystem 100 can include one or more input boxes for text, voice, and images. Taking a text input box as an example, when a target user needs the task processing system's assistance to complete a task, the target user can input their request information into the text input box. After inputting the information, the user request information can be submitted to the user interaction subsystem 100 in the task processing system. The user interaction subsystem 100 can parse the received user request information, determine the target user's intent, and break down the user request information based on the target user's intent, thereby separating it into multiple independently executable sub-tasks. A task can also determine the execution priority of multiple subtasks and the dependencies between different subtasks. For example, for the user requirement "Generate the November project weekly report (including project progress, cost consumption, problem summary, etc.) and synchronize it to the R&D department's SharePoint folder", two subtasks can be generated: Subtask 1: Data extraction + generating the November project weekly report; Subtask 2: Synchronize the project weekly report to the SharePoint folder. Subtask 1 has the highest priority, and Subtask 2 has the second highest priority. Accordingly, Subtask 2 depends on Subtask 1, and the execution order of the subtasks can be Subtask 1 → Subtask 2.

[0024] The intelligent agent subsystem 300 is configured to obtain subtasks corresponding to user demand information input by the target user from the user interaction subsystem 100, as well as the dependencies between different subtasks; invoke the intelligent agent management subsystem 200, and based on the capability evaluation information of each intelligent agent in the intelligent agent subsystem 300 provided by the intelligent agent management subsystem 200, determine the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information; execute the subtasks sequentially through the corresponding intelligent agents according to the intelligent agent information to execute each subtask and the dependencies between different subtasks, and obtain the corresponding execution results; and generate and output the response results corresponding to the user demand information based on the obtained execution results.

[0025] In implementation, the agent subsystem 300 can obtain the subtasks to be executed and the dependencies between different subtasks from the user interaction subsystem 100. For the subtasks to be executed, the agent management subsystem 200 can be invoked to query the capability assessment information of each agent in the agent subsystem 300. Based on the capabilities of each agent, a corresponding agent can be matched for each subtask. For example, the agent subsystem 300 may include a data extraction agent and a document processing agent. The data extraction agent can be used to obtain project progress, cost data, etc., and the document processing agent can be used to generate project weekly reports. Based on this, the subtask "Generate November project weekly report (including project progress, cost consumption, problem summary, etc.)" can be matched with the above-mentioned data extraction agent and document processing agent. For multiple different subtasks, the corresponding agents can also be matched in the above way, thereby determining the agent information for executing each subtask. Then, the intelligent agent subsystem 300 can execute subtasks sequentially through the corresponding intelligent agents according to the intelligent agent information executing each subtask and the dependencies between different subtasks, based on the subtask execution order matching the dependencies between different subtasks, and obtain the execution result of each subtask. The execution results of each subtask can be merged to generate a response result corresponding to the user's request information, which can then be pushed to the user interaction subsystem 100. The user interaction subsystem 100 can provide feedback in the form of pop-ups and notifications. Through autonomous decomposition and dependency modeling, the system can automatically identify the task type and constraints in the user's request information without requiring manual task splitting by the user. Based on the logic of "data first, content second; generation first, synchronization second," it establishes subtask dependencies, thereby better covering scenarios involving the parsing of ambiguous user request information and improving the adaptability to complex tasks.

[0026] It should be noted that for matching the above-mentioned different sub-tasks with the corresponding intelligent agents, a target user-specific intelligent agent capability evaluation system can be established in advance. The intelligent agents can be scored and evaluated from multiple dimensions such as "functional matching degree (e.g., whether the document processing intelligent agent supports the project weekly report template), historical success rate (e.g., the success rate of the synchronization intelligent agent in the past (e.g., 10 or 15 times), and response speed (e.g., the average time taken by the data extraction intelligent agent)". When matching sub-tasks, high-scoring intelligent agents are prioritized, and a certain number (e.g., 2-3) of alternative intelligent agents can be automatically reserved. This can improve the success rate of sub-task execution and reduce the user's decision-making cost.

[0027] This specification provides a task processing system, including a user interaction subsystem, an agent management subsystem, and an agent subsystem. The agent management subsystem assesses the capabilities of each agent within the agent subsystem, determining the capability assessment information for each agent. The user interaction subsystem receives user request information input by a target user, parses the user request information, determines the subtasks corresponding to the user request information, and the dependencies between different subtasks. The agent subsystem obtains the subtasks corresponding to the user request information input by the target user, as well as the dependencies between different subtasks. Then, it can call the agent management subsystem and, based on the capability assessment information of each agent within the agent subsystem provided by the agent management subsystem, process the subtasks according to the user request information. The system first identifies the agent information for each subtask. Then, based on the agent information and the dependencies between different subtasks, the system executes the subtasks sequentially through the corresponding agents, obtaining the corresponding execution results. Finally, based on the obtained execution results, the system generates and outputs the response result corresponding to the user's request information. In this way, the user only needs to input fuzzy user request information, and the system will automatically break it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Moreover, it supports cross-ecosystem agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously coordinate agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0028] Figure 2 This specification provides yet another task processing system as an embodiment. The task processing system includes... Figure 1 The system for processing the task shown comprises all functional units, and improvements have been made to it as follows: The user interaction subsystem 100 includes a requirement analysis unit 110 and a task decomposition unit 120, wherein: The requirement parsing unit 110 is configured to extract information from user requirement information to obtain key information corresponding to the user requirement information. The key information includes one or more of the user requirement objectives and constraints.

[0029] In implementation, the requirement analysis unit 110 can extract information from user requirement information to obtain key information corresponding to the user requirement information. Taking the above user requirement information "generate November project weekly report (including project progress, cost consumption, problem summary, etc.) and synchronize it to the R&D department SharePoint folder" as an example, the key information that can be obtained includes: task objective: generate project weekly report and synchronize project weekly report file; constraints may include: the weekly report contains 3 types of content and synchronizes to the R&D department SharePoint folder.

[0030] The task decomposition unit 120 is configured to generate subtasks corresponding to user requirement information and the dependencies between different subtasks based on key information corresponding to user requirement information.

[0031] In implementation, based on the above example, the task decomposition unit 120 can decompose subtasks based on the above task objectives and constraints, resulting in subtask 1: data extraction + generation of November project weekly report; subtask 2: synchronization of project weekly report to SharePoint folder. The dependency relationship between different subtasks is that subtask 2 depends on subtask 1. Based on this, the execution order of subtasks can be subtask 1 → subtask 2.

[0032] In practical applications, the task processing system also includes a data sharing subsystem 400, which is configured to store the execution results of different subtasks and provide corresponding data for the execution of each subtask.

[0033] In implementation, such as Figure 3 As shown in the example above, relevant information for a specified project can be stored in the data sharing subsystem 400 with the authorization of the target user. When the first subtask is executed, the relevant information for the specified project can be retrieved from the data sharing subsystem 400. The corresponding intelligent agent executes the first subtask based on the retrieved relevant information for the specified project, obtains the corresponding execution result, and writes the execution result into the data sharing subsystem 400. Then, the second subtask can be triggered, retrieving the execution result of the first subtask from the data sharing subsystem 400. The corresponding intelligent agent executes the second subtask based on the retrieved execution result of the first subtask, obtains the corresponding execution result, and writes the execution result into the data sharing subsystem 400, and so on, until each subtask is completed.

[0034] In practical applications, such as Figure 4As shown, the intelligent agent subsystem 300 includes a collaborative scheduling module 310 and a multi-agent module 320, in which various intelligent agents are configured. The collaborative scheduling module 310 is configured to obtain the sub-tasks corresponding to the user demand information input by the target user, as well as the dependencies between different sub-tasks; call the intelligent agent management subsystem 200, and based on the capability evaluation information of each intelligent agent in the multi-agent module 320 provided by the intelligent agent management subsystem 200, determine the intelligent agent information to execute each sub-task according to the sub-tasks corresponding to the user demand information; according to the intelligent agent information to execute each sub-task and the dependencies between different sub-tasks, sequentially call the corresponding intelligent agents to execute the sub-tasks and obtain the corresponding execution results; based on the obtained execution results, generate and output the response result corresponding to the user demand information.

[0035] In practical applications, user demand information includes a resource transfer information sheet for the target user. The sub-tasks corresponding to the user demand information include one or more of the following: key information extraction, generating a resource transfer analysis report for a preset time period, extracting the conclusions of the analysis report and generating a presentation, constructing a user profile for the target user, and suggestions for the target user.

[0036] The resource transfer information form can be such as an order or invoice. It can include the account information of both parties involved in the resource transfer, the transfer time, the target of the transfer (e.g., a specific product or service), and the quantity transferred. The preset time period can be such as the most recent month or the most recent year, and can be set according to actual needs. The resource transfer analysis report can be a payment and / or receipt-related analysis report. It can include daily and monthly payment and / or receipt information, daily or monthly resource transfer distribution, and information on different resource transfer types and their distribution, and can be set according to actual needs.

[0037] Based on the above, the following is a detailed explanation using an example. The subtasks corresponding to the user requirement information include subtask 1, subtask 2, subtask 3, and subtask 4. The dependencies between different subtasks include that after subtask 1 is executed, subtasks 2 and 3 are executed in parallel, and after subtasks 2 and 3 are executed, subtask 4 is executed. The agent information for executing each subtask includes agent A executing subtask 1, agent B executing subtask 2, agent C executing subtask 3, and agent D executing subtask 4. Then, the collaborative scheduling module 310, according to the agent information for executing each subtask and the dependencies between different subtasks, sequentially calls the corresponding agents to execute the subtasks and obtain the corresponding execution results. The specific processing can include the following steps A02 to A12.

[0038] In step A02, the collaborative scheduling module 310 executes subtask 1 through agent A, and after the execution of subtask 1 is completed, it stores the execution result of subtask 1 in the data sharing subsystem 400.

[0039] In step A04, when the collaborative scheduling module 310 detects that subtask 1 has been completed, it triggers subtask 2 and subtask 3 to be executed in parallel.

[0040] In step A06, the collaborative scheduling module 310 obtains the execution result of subtask 1 from the data sharing subsystem 400 through agent B, and executes subtask 2 based on the execution result of subtask 1. At the same time, it obtains the execution result of subtask 1 from the data sharing subsystem 400 through agent C, and executes subtask 3 based on the execution result of subtask 1. After subtask 2 and subtask 3 are executed, the execution results of subtask 2 and subtask 3 are stored in the data sharing subsystem 400.

[0041] In step A08, when the collaborative scheduling module 310 detects that subtasks 2 and 3 have been completed, it triggers the execution of subtask 4.

[0042] In step A10, the collaborative scheduling module 310 obtains the execution results of subtask 1, subtask 2 and subtask 3 from the data sharing subsystem 400 through the intelligent agent D, and executes subtask 4 based on the execution results of subtask 1, subtask 2 and subtask 3 to obtain the execution result of subtask 4.

[0043] In addition, a two-level data permission model of "user-agent" can be constructed, whereby users can preset the data access scope of agents (e.g., "remind the agent that it can only read member contact information and cannot modify it"). All input and / or output data of agents are stored in a unified data pool, supporting data reuse across agents (e.g., project weekly reports generated by document processing agents can be directly read by synchronization agents without requiring users to upload them repeatedly). This reduces repetitive input operations by users and ensures the consistency of task data (e.g., file links, member information, etc.).

[0044] In addition, the attribute information of the agents in the agent subsystem can be customized by the user. For example, a document processing agent with a dedicated weekly report template can be bound to a synchronization agent with a commonly used SharePoint path. Based on the user's historical task data (such as "generate project weekly reports every Friday"), scenario-based collaboration rules can be established (such as "automatically trigger the process of 'data extraction → weekly report generation → synchronization to team folder' at 2 pm every Friday"). In this way, it can adapt to the user's long-term fixed work scenario, further reduce the operation cost and improve the ease of use.

[0045] In practical applications, such as Figure 5 As shown, if the collaborative scheduling module 310 detects an anomaly during the execution of a subtask by the corresponding intelligent agent, the collaborative scheduling module 310 can automatically trigger the execution of the following steps B2 to B8 through the dynamic adjustment unit 311.

[0046] In step B2, the collaborative scheduling module 310 determines whether there are alternative processing strategies for the subtask that has an anomaly.

[0047] Among them, the alternative processing strategy can be a candidate processing strategy for the main strategy. That is, when the main strategy fails or an exception occurs, the alternative processing strategy can be executed. For example, the main strategy can be SharePoint synchronization, and the alternative processing strategy can be cloud disk synchronization. That is, when an exception occurs during SharePoint synchronization, the data synchronization can be achieved through the alternative processing strategy of cloud disk synchronization. The specific settings can be configured according to the actual situation.

[0048] In step B4, if it exists, the collaborative scheduling module 310 re-executes the subtask that has an error, and continues to execute the subtasks after the subtask that has an error, based on the alternative processing agent corresponding to the alternative processing strategy.

[0049] In step B6, if the subtask does not exist, the collaborative scheduling module 310 repairs the factors that caused the subtask to malfunction, and after the repair is completed, re-executes the subtask that malfunctioned, and after the re-execution is completed, continues to execute the subtasks following the subtask that malfunctioned.

[0050] In implementation, if no alternative processing strategy exists, the collaborative scheduling module 310 can detect factors causing subtask anomalies. These factors could include a section of program code or a network error. The collaborative scheduling module 310 can then repair these factors. For example, it can fix the problematic section of program code to improve its integrity, or it can repair the network error. After repair, the collaborative scheduling module 310 can re-execute the subtask that caused the anomaly, and then continue executing subsequent subtasks after the one that caused the anomaly.

[0051] Through the above processing, a closed-loop collaboration of "task execution - status monitoring - anomaly handling - result update" can be achieved. The system monitors the execution status of each intelligent agent in real time. When anomalies such as interface timeout or data error occur, a backup intelligent agent is automatically scheduled for retry. If the retry fails, a "problem description + solution options (such as 'whether to switch to cloud disk synchronization')" can be pushed to the user. After the user confirms, execution can continue. After the task is updated, it is automatically synchronized to subsequent subtasks (such as the reminder content is automatically updated after the synchronization link changes), thereby ensuring the continuity of complex task processes and reducing the task interruption rate.

[0052] Based on the above, the following describes in detail a task processing method provided by the embodiments of this specification, combined with specific application scenarios. (See also...) Figure 5 and Figure 6 As shown, the details are as follows: The user interaction subsystem 100 receives user request information input by the target user through a text input box: "Generate the November project weekly report (including project progress, cost consumption, and problem summary), synchronize it to the R&D department's SharePoint folder, extract 3 core conclusions to generate a PPT summary, and remind manager Zhao Liu to approve it before 5 PM today."

[0053] The user interaction subsystem 100 extracts user requirement information through the requirement analysis unit 110 to obtain the task objectives: generate project weekly reports, synchronize project weekly reports, generate PPTs, and send reminders; constraints: the project weekly reports contain 3 types of content, are synchronized to the R&D department's SharePoint folder, the PPTs contain 3 core conclusions, and the reminder deadline is 5 PM today, etc.

[0054] The user interaction subsystem 100 generates subtasks corresponding to user needs based on key information corresponding to user needs information through the task decomposition unit 120, as well as the dependencies between different subtasks. The subtasks include: subtask 1 (data extraction + generation of November project weekly report), subtask 2 (synchronizing project weekly report to SharePoint folder), subtask 3 (extracting conclusions to generate PPT), and subtask 4 (reminding Zhao Liu to approve). The dependencies between different subtasks are as follows: after subtask 1 is completed, subtask 2 and subtask 3 are executed in parallel; after subtask 2 and 3 are completed, subtask 4 is executed.

[0055] The collaborative scheduling module 310 calls the agent management subsystem 200. Based on the agent capability assessment model in the agent management subsystem 200, it matches a "data extraction agent + document processing agent" for subtask 1 (the data extraction agent is responsible for obtaining project progress and cost data, etc., and the document processing agent is responsible for generating project weekly reports); it matches a "SharePoint synchronization agent" for subtask 2 (the SharePoint synchronization agent has the permission to access the enterprise SharePoint interface); it matches a "PPT generation agent" for subtask 3 (the PPT generation agent supports extracting core conclusions from documents and generating PPTs); and it matches a "reminder agent" for subtask 4 (the reminder agent supports instant messaging applications or email reminders and stores Zhao Liu's communication account).

[0056] The collaborative scheduling module 310 triggers the execution of subtask 1: the data extraction agent reads "November project data" (stored after initial authorization by the target user) from the data sharing subsystem 400 and outputs the data to the document processing agent; the document processing agent generates a project weekly report based on a preset template, completes format verification, writes the project weekly report file to the data sharing subsystem 400, and sends a "Subtask 1 completed" message to the collaborative scheduling module 310.

[0057] The collaborative scheduling module 310 triggers the parallel execution of subtasks 2 and 3: After receiving the completion signal of subtask 1, the collaborative scheduling module 310 simultaneously triggers subtasks 2 and 3; Subtask 2: The SharePoint synchronization agent reads the project weekly report file from the data sharing subsystem 400, uploads it to the "R&D Department - Project Weekly Report" folder through the enterprise SharePoint interface, and reports "Subtask 2 completed"; Subtask 3: The PPT generation agent extracts three core conclusions from the project weekly report: "Progress met, cost exceeded by 5%, and design resources need to be coordinated", generates a 3-page PPT summary, writes it to the data sharing subsystem 400, and reports "Subtask 3 completed".

[0058] After receiving the completion signals of subtasks 2 and 3, the collaborative scheduling module 310 triggers subtask 4; it reminds the agent to read Zhao Liu's communication account, weekly report link, and PPT link from the data sharing subsystem 400, generates a reminder message ("The November project weekly report has been synchronized to SharePoint, and the core conclusion PPT has been generated. Please approve it before 5 PM today. Link: xxx"), and sends it to report "Subtask 4 completed".

[0059] The collaborative scheduling module 310 integrates the execution results of all sub-tasks and pushes them to the user interaction subsystem 100. The user interaction subsystem 100 provides feedback in the form of "pop-up window + notification": "The November project weekly report has been generated (click to view), and has been synchronized to the R&D department's SharePoint (click to jump). The core conclusion PPT has been generated (click to download). Zhao Liu has been reminded to approve it before 5 pm today. Current status: pending approval."

[0060] Furthermore, if the collaborative scheduling module 310 detects an anomaly during the execution of a subtask by the corresponding intelligent agent, the collaborative scheduling module 310 can be automatically triggered by the dynamic adjustment unit 311: Call the "alternate synchronization agent" (such as the cloud drive synchronization agent) in the agent management subsystem 200; push a prompt to the user interaction subsystem 100: "SharePoint synchronization failed, switched to cloud drive synchronization, the link will be updated after synchronization"; after the alternative synchronization agent completes the upload, update the file link in the data sharing subsystem 400, and re-trigger subtask 4 (remind the agent to send a supplementary reminder containing the new link).

[0061] This specification provides a task processing system, including a user interaction subsystem, an agent management subsystem, and an agent subsystem. The agent management subsystem assesses the capabilities of each agent within the agent subsystem, determining the capability assessment information for each agent. The user interaction subsystem receives user request information input by a target user, parses the user request information, determines the subtasks corresponding to the user request information, and the dependencies between different subtasks. The agent subsystem obtains the subtasks corresponding to the user request information input by the target user, as well as the dependencies between different subtasks. Then, it can call the agent management subsystem and, based on the capability assessment information of each agent within the agent subsystem provided by the agent management subsystem, process the subtasks according to the user request information. The system first identifies the agent information for each subtask. Then, based on the agent information and the dependencies between different subtasks, the system executes the subtasks sequentially through the corresponding agents, obtaining the corresponding execution results. Finally, based on the obtained execution results, the system generates and outputs the response result corresponding to the user's request information. In this way, the user only needs to input fuzzy user request information, and the system will automatically break it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Moreover, it supports cross-ecosystem agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously coordinate agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0062] Furthermore, all agents share a unified data pool containing user-related and execution data, eliminating the need for manual input and reducing repetitive data entry while improving data accuracy. Each subtask can have multiple (e.g., 2-3) backup agents. If the primary agent fails, the system automatically schedules a backup agent to continue execution and pushes progress updates to the user, requiring no manual intervention. This increases task success rate and avoids delays caused by single-tool failures. Users can also customize agent attributes and set scenario-based rules to further improve operational efficiency and adapt to customized processes across different industries.

[0063] like Figure 7 As shown in the embodiments of this specification, a task processing method is provided. The execution subject of this method can be an intelligent agent subsystem, which can run on a terminal device or a server. The terminal device can be a mobile terminal device such as a mobile phone or tablet computer, or a computer device such as a laptop or desktop computer, or an IoT device (specifically, a smartwatch, in-vehicle device, etc.). The server can be a single server or a server cluster composed of multiple servers. The server can be a backend server for financial or online shopping services, or a backend server for an application. This embodiment uses a server as the execution subject for detailed explanation. For the case where the execution subject is a terminal device, please refer to the following server-side processing, which will not be repeated here. The method may specifically include the following steps: In step S702, the subtasks corresponding to the user demand information input by the target user and the dependencies between different subtasks are obtained.

[0064] In step S704, the agent management subsystem is invoked, and based on the capability assessment information of each agent in the agent subsystem provided by the agent management subsystem, the agent information for executing each subtask is determined according to the subtask corresponding to the user requirement information.

[0065] In step S706, based on the agent information for each subtask and the dependencies between different subtasks, the subtasks are executed sequentially through the corresponding agents to obtain the corresponding execution results.

[0066] In step S708, based on the obtained execution results, a response result corresponding to the user's requirement information is generated and output.

[0067] This specification provides a task processing method. It obtains subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it invokes an intelligent agent management subsystem and, based on the capability evaluation information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determines the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, the subtasks are executed sequentially through the corresponding intelligent agents to obtain the corresponding execution results. Finally, based on the obtained execution results, a response result corresponding to the user demand information is generated and output. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0068] In practical applications, user demand information includes a resource transfer information sheet for the target user. The sub-tasks corresponding to the user demand information include one or more of the following: key information extraction, generating a resource transfer analysis report for a preset time period, extracting the conclusions of the analysis report and generating a presentation, constructing a user profile for the target user, and suggestions for the target user.

[0069] In practical applications, the subtasks corresponding to user demand information include subtask 1, subtask 2, subtask 3, and subtask 4. The dependencies between different subtasks include: after subtask 1 is executed, subtasks 2 and 3 are executed in parallel; after subtasks 2 and 3 are executed, subtask 4 is executed. The agent information for each subtask includes agent A executing subtask 1, agent B executing subtask 2, agent C executing subtask 3, and agent D executing subtask 4. Based on this, the specific processing method of step S706 can be varied. The following provides another optional processing method, which specifically includes the processing of steps S70602 to S70610. Based on this, in the above... Figure 7 Based on this, the specific steps included in this method can be as follows: Figure 8 As shown.

[0070] In step S70602, subtask 1 is executed by agent A, and after subtask 1 is completed, the execution result of subtask 1 is stored in the data sharing subsystem.

[0071] In step S70604, when the cooperative scheduling module detects that subtask 1 has been completed, it triggers subtask 2 and subtask 3 to be executed in parallel.

[0072] In step S70606, agent B obtains the execution result of subtask 1 from the data sharing subsystem and executes subtask 2 based on the execution result of subtask 1. At the same time, agent C obtains the execution result of subtask 1 from the data sharing subsystem and executes subtask 3 based on the execution result of subtask 1. After subtask 2 and subtask 3 are executed, the execution results of subtask 2 and subtask 3 are stored in the data sharing subsystem.

[0073] In step S70608, when the collaborative scheduling module detects that subtask 2 and subtask 3 have been completed, subtask 4 is triggered to execute.

[0074] In step S70610, the execution results of subtask 1, subtask 2 and subtask 3 are obtained from the data sharing subsystem by the intelligent agent D. Based on the execution results of subtask 1, subtask 2 and subtask 3, subtask 4 is executed to obtain the execution result of subtask 4.

[0075] In practical applications, if an exception occurs during the execution of a subtask by the corresponding intelligent agent, it can be handled through the following steps D2 to D6.

[0076] In step D2, it is determined whether there are alternative processing strategies for the subtask that has an anomaly.

[0077] In step D4, if such a subtask exists, the subtask that caused the exception is re-executed based on the alternative processing agent corresponding to the alternative processing strategy, and the subtasks following the subtask that caused the exception are continued to be executed.

[0078] In step D6, if the factor causing the subtask to malfunction is not present, the subtask is repaired, and after the repair is completed, the subtask that malfunctioned is re-executed. After the re-execution is completed, the subtasks following the subtask that malfunctioned are executed.

[0079] This specification provides a task processing method. It obtains subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it invokes an intelligent agent management subsystem and, based on the capability evaluation information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determines the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, the subtasks are executed sequentially through the corresponding intelligent agents to obtain the corresponding execution results. Finally, based on the obtained execution results, a response result corresponding to the user demand information is generated and output. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0080] Furthermore, all agents share a unified data pool containing user-related and execution data, eliminating the need for manual input and reducing repetitive data entry while improving data accuracy. Each subtask can have multiple (e.g., 2-3) backup agents. If the primary agent fails, the system automatically schedules a backup agent to continue execution and pushes progress updates to the user, requiring no manual intervention. This increases task success rate and avoids delays caused by single-tool failures. Users can also customize agent attributes and set scenario-based rules to further improve operational efficiency and adapt to customized processes across different industries.

[0081] The task processing system provided in one or more embodiments of this specification is applicable to the implementation environment of task processing. (Refer to...) Figure 9 The system includes a user interaction subsystem 100, an intelligent agent management subsystem 200, a collaborative scheduling subsystem 300, and an intelligent agent subsystem 400. The intelligent agent subsystem 400 includes various intelligent agents, among which: In practical applications, the agent management subsystem 200 is configured to evaluate the capabilities of each agent in the agent subsystem 400 and determine the capability evaluation information of each agent in the agent subsystem 400.

[0082] The user interaction subsystem 100 is configured to receive user demand information input by the target user, parse the user demand information, determine the sub-tasks corresponding to the user demand information, and the dependencies between different sub-tasks.

[0083] The collaborative scheduling subsystem 300 is configured to obtain subtasks corresponding to user demand information input by the target user from the user interaction subsystem 100, as well as the dependencies between different subtasks; call the agent management subsystem 200, and based on the capability evaluation information of each agent in the agent subsystem 400 provided by the agent management subsystem 200, determine the agent information to execute each subtask according to the subtasks corresponding to the user demand information; execute the subtasks sequentially through the corresponding agents according to the agent information to execute each subtask and the dependencies between different subtasks, and obtain the corresponding execution results; and generate and output the response results corresponding to the user demand information based on the obtained execution results.

[0084] In practical applications, the collaborative scheduling subsystem 300 can have the same or similar functions as the collaborative scheduling module in the intelligent agent subsystem of the above embodiments. The specific processing procedure can be found in the aforementioned related content and will not be repeated here. The intelligent agent subsystem 400 can have the same or similar functions as the multi-agent module in the intelligent agent subsystem of the above embodiments. The specific processing procedure can be found in the aforementioned related content and will not be repeated here. It should be noted that for the matching of the above different sub-tasks with the corresponding intelligent agents, a target user-specific intelligent agent capability evaluation system can be established in advance. This system scores and evaluates intelligent agents from multiple dimensions, such as "functional matching degree (e.g., whether the document processing intelligent agent supports the project weekly report template), historical success rate (e.g., the success rate of the synchronization intelligent agent in the past (e.g., 10 or 15 times), and response speed (e.g., the average time consumed by the data extraction intelligent agent)." When matching sub-tasks, high-scoring intelligent agents are prioritized, and a certain number (e.g., 2-3) of alternative intelligent agents can be automatically reserved. This can improve the sub-task execution success rate and reduce user decision-making costs.

[0085] This specification provides a task processing system, including a user interaction subsystem, an agent management subsystem, a collaborative scheduling subsystem, and an agent subsystem. The agent subsystem includes various agents. Specifically: the agent management subsystem assesses the capabilities of each agent within the agent subsystem, determining their capability assessment information; the user interaction subsystem receives user request information input by a target user, parses the user request information, determines the corresponding subtasks, and the dependencies between different subtasks; the collaborative scheduling subsystem obtains the subtasks corresponding to the user request information input by the target user, and the dependencies between different subtasks; then, it can call the agent management subsystem and, based on the capability assessment information of each agent within the agent subsystem provided by the agent management subsystem, proceed according to... The system identifies the agent information for each subtask corresponding to the user's needs. Then, based on the agent information and dependencies between different subtasks, the system sequentially calls the corresponding agents in the agent system to execute the subtasks, obtaining the corresponding execution results. Finally, based on the obtained execution results, the system generates and outputs the response result corresponding to the user's needs. In this way, the user only needs to input fuzzy user needs information, and the system automatically breaks it down into multiple different, independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0086] Figure 10 This specification provides yet another task processing system as an embodiment. The task processing system includes... Figure 9 The system for processing the task shown comprises all functional units, and improvements have been made to it as follows: The user interaction subsystem 100 includes a requirement analysis unit 110 and a task decomposition unit 120, wherein: The requirement parsing unit 110 is configured to extract information from user requirement information to obtain key information corresponding to the user requirement information. The key information includes one or more of the user requirement objectives and constraints.

[0087] The task decomposition unit 120 is configured to generate subtasks corresponding to user requirement information and the dependencies between different subtasks based on key information corresponding to user requirement information.

[0088] In practical applications, such as Figure 11As shown, the task processing system also includes a data sharing subsystem 500, which is configured to store the execution results of different subtasks and provide corresponding data for the execution of each subtask.

[0089] In practical applications, user demand information includes a resource transfer information sheet for the target user. The sub-tasks corresponding to the user demand information include one or more of the following: key information extraction, generating a resource transfer analysis report for a preset time period, extracting the conclusions of the analysis report and generating a presentation, constructing a user profile for the target user, and suggestions for the target user.

[0090] Based on the above, the following example provides a detailed explanation. The subtasks corresponding to the user's requirements include subtask 1, subtask 2, subtask 3, and subtask 4. The dependencies between different subtasks include: after subtask 1 is executed, subtasks 2 and 3 are executed in parallel; after subtasks 2 and 3 are executed, subtask 4 is executed. The agent information for each subtask includes: agent A executes subtask 1, agent B executes subtask 2, agent C executes subtask 3, and agent D executes subtask 4. The collaborative scheduling subsystem 300, based on the agent information for each subtask and the dependencies between different subtasks, sequentially calls the corresponding agents to execute the subtasks and obtain the corresponding execution results. The specific processing may include the following: the collaborative scheduling subsystem 300 executes subtask 1 through agent A, and after subtask 1 is completed, stores the execution result of subtask 1 in the data sharing subsystem 500; the collaborative scheduling subsystem 300 detects the execution of subtask 1... Upon completion, subtasks 2 and 3 are executed in parallel. The collaborative scheduling subsystem 300 obtains the execution result of subtask 1 from the data sharing subsystem 500 through agent B, and executes subtask 2 based on the execution result of subtask 1. At the same time, it obtains the execution result of subtask 1 from the data sharing subsystem 500 through agent C, and executes subtask 3 based on the execution result of subtask 1. After the execution of subtasks 2 and 3 is completed, the execution results of subtask 2 and subtask 3 are stored in the data sharing subsystem 500. When the collaborative scheduling subsystem 300 detects that subtasks 2 and 3 have been completed, it triggers the execution of subtask 4. The collaborative scheduling subsystem 300 obtains the execution results of subtask 1, subtask 2, and subtask 3 from the data sharing subsystem 500 through agent D, and executes subtask 4 based on the execution results of subtask 1, subtask 2, and subtask 3, thus obtaining the execution result of subtask 4.

[0091] In addition, a two-level data permission model of "user-agent" can be constructed, whereby users can preset the data access scope of agents (e.g., "remind the agent that it can only read member contact information and cannot modify it"). All input and / or output data of agents are stored in a unified data pool, supporting data reuse across agents (e.g., project weekly reports generated by document processing agents can be directly read by synchronization agents without requiring users to upload them repeatedly). This reduces repetitive input operations by users and ensures the consistency of task data (e.g., file links, member information, etc.).

[0092] In addition, the attribute information of the agents in the agent subsystem can be customized by the user. For example, a document processing agent with a dedicated weekly report template can be bound to a synchronization agent with a commonly used SharePoint path. Based on the user's historical task data (such as "generate project weekly reports every Friday"), scenario-based collaboration rules can be established (such as "automatically trigger the process of 'data extraction → weekly report generation → synchronization to team folder' at 2 pm every Friday"). In this way, it can adapt to the user's long-term fixed work scenario, further reduce the operation cost and improve the ease of use.

[0093] In practical applications, such as Figure 12 As shown, if the collaborative scheduling subsystem 300 detects an anomaly during the execution of a subtask by the corresponding intelligent agent, the collaborative scheduling subsystem 300 can automatically trigger the following processing through the dynamic adjustment unit 311: The collaborative scheduling subsystem 300 determines whether there is an alternative processing strategy for the subtask that caused the anomaly; if there is, the collaborative scheduling subsystem 300, through the alternative processing intelligent agent corresponding to the alternative processing strategy, re-executes the subtask that caused the anomaly, and continues to execute the subtasks following the subtask that caused the anomaly; if there is no alternative processing strategy, the collaborative scheduling subsystem 300 repairs the factors that caused the anomaly in the subtask, and after the repair is completed, re-executes the subtask that caused the anomaly, and after the re-execution is completed, continues to execute the subtasks following the subtask that caused the anomaly.

[0094] Through the above processing, a closed-loop collaboration of "task execution - status monitoring - anomaly handling - result update" can be achieved. The system monitors the execution status of each intelligent agent in real time. When anomalies such as interface timeout or data error occur, a backup intelligent agent is automatically scheduled for retry. If the retry fails, a "problem description + solution options (such as 'whether to switch to cloud disk synchronization')" can be pushed to the user. After the user confirms, execution can continue. After the task is updated, it is automatically synchronized to subsequent subtasks (such as the reminder content is automatically updated after the synchronization link changes), thereby ensuring the continuity of complex task processes and reducing the task interruption rate.

[0095] Based on the above, the following describes in detail a task processing method provided by the embodiments of this specification, combined with specific application scenarios. (See also...) Figure 12 and Figure 13 As shown, the details are as follows: The user interaction subsystem 100 receives user request information input by the target user through a text input box: "Generate a resource transfer analysis report for the previous year (including resource transfer sources and quantities, monthly resource transfer distribution, resource transfer types and distribution), synchronize it to my cloud drive, extract the conclusions of the analysis report to generate a presentation, share it with user AA and remind them." The resource transfer can be payment and / or receipt, etc., and can be specifically set according to the actual situation.

[0096] The user interaction subsystem 100 extracts user demand information through the demand analysis unit 110 to obtain the task objectives: generate a resource transfer analysis report, synchronize the resource transfer analysis report, generate a PPT, and share reminders; constraints: the resource transfer analysis report contains 3 types of content, synchronizes to my cloud drive, the PPT contains 3 core conclusions, and shares reminders and other key information.

[0097] The user interaction subsystem 100 generates subtasks corresponding to user needs based on key information corresponding to user needs information through the task decomposition unit 120, as well as the dependencies between different subtasks. The subtasks include: subtask 1 (data extraction + generation of the previous year's resource transfer analysis report), subtask 2 (synchronizing the resource transfer analysis report to my cloud drive), subtask 3 (extracting conclusions and generating a PPT), and subtask 4 (sharing with user AA and reminding them). The dependencies between different subtasks are as follows: after subtask 1 is completed, subtask 2 and subtask 3 are executed in parallel; after subtask 2 and 3 are completed, subtask 4 is executed.

[0098] The collaborative scheduling subsystem 300 calls the agent management subsystem 200. Based on the agent capability assessment model in the agent management subsystem 200, it matches a "data extraction agent + document processing agent" for subtask 1 (the data extraction agent is responsible for obtaining the source and quantity of resource transfers, monthly resource transfer distribution, resource transfer types and distribution, etc., and the document processing agent is responsible for generating resource transfer analysis reports); it matches a "cloud disk synchronization agent" for subtask 2 (the cloud disk synchronization agent has the permission to access the cloud disk interface); it matches a "PPT generation agent" for subtask 3 (the PPT generation agent supports extracting core conclusions from the resource transfer analysis report and generating PPTs); and it matches a "sharing reminder agent" for subtask 4 (the reminder agent supports instant messaging applications and stores user AA's communication account).

[0099] The collaborative scheduling subsystem 300 triggers the execution of subtask 1: it calls the data extraction agent to read the "Resource Transfer Information Sheet of the Target User in the Previous Year" (stored after the target user's prior authorization) from the data sharing subsystem 500, and outputs the data to the document processing agent; it calls the document processing agent to generate a resource transfer analysis report based on a preset template, and after completing the format verification, writes the resource transfer analysis report to the data sharing subsystem 500 and sends a "Subtask 1 Completed" message to the collaborative scheduling subsystem 100.

[0100] The collaborative scheduling subsystem 300 triggers the parallel execution of subtasks 2 and 3: After receiving the completion signal of subtask 1, the collaborative scheduling subsystem 300 simultaneously triggers subtasks 2 and 3; Subtask 2: Calls the cloud disk synchronization agent to read the resource transfer analysis report from the data sharing subsystem 500, uploads it to "My Cloud Disk" through the cloud disk interface, and reports "Subtask 2 completed"; Subtask 3: The PPT generation agent extracts three core conclusions from the resource transfer analysis report: "source and quantity of resource transfer, monthly resource transfer distribution, and type and distribution of resource transfer", generates a PPT, writes it to the data sharing subsystem 500, and reports "Subtask 3 completed".

[0101] After receiving the completion signals of subtasks 2 and 3, the collaborative scheduling subsystem 300 triggers subtask 4; it calls the sharing reminder agent to read user AA's communication account, resource transfer analysis report link, and PPT link from the data sharing subsystem 500, and generates a reminder message ("The previous year's resource transfer analysis report has been synchronized to my cloud drive, and the core conclusion PPT has been generated. Please check it. Link: xxx"). After sharing, it sends a feedback message "Subtask 4 completed".

[0102] The collaborative scheduling subsystem 300 integrates the execution results of all subtasks and pushes them to the user interaction subsystem 100. The user interaction subsystem 100 provides feedback in the form of "pop-up window + notification": "The resource transfer analysis report of the previous year has been generated (click to view), and has been synchronized to my cloud drive (click to jump). The core conclusion PPT has been generated (click to download), and has been shared with user AA and reminded. Current status: pending receipt."

[0103] Furthermore, if the cooperative scheduling subsystem 300 detects an anomaly during the execution of a subtask by the corresponding intelligent agent, the cooperative scheduling subsystem 300 can automatically trigger the dynamic adjustment unit 310: Call the "Repair Agent" function in the Agent Management Subsystem 200; push a notification to the User Interaction Subsystem 100: "Cloud disk synchronization failed, searching for and repairing related issues"; repair the abnormal program code in the Agent Repair subsystem; after the repair is completed, re-synchronize the resource transfer analysis report to my cloud disk; after the synchronization is completed, re-trigger subtask 4.

[0104] This specification provides a task processing system, including a user interaction subsystem, an agent management subsystem, a collaborative scheduling subsystem, and an agent subsystem. The agent subsystem includes various agents. Specifically: the agent management subsystem assesses the capabilities of each agent within the agent subsystem, determining their capability assessment information; the user interaction subsystem receives user request information input by a target user, parses the user request information, determines the corresponding subtasks, and the dependencies between different subtasks; the collaborative scheduling subsystem obtains the subtasks corresponding to the user request information input by the target user, and the dependencies between different subtasks; then, it can call the agent management subsystem and, based on the capability assessment information of each agent within the agent subsystem provided by the agent management subsystem, proceed according to... The system identifies the agent information for each subtask corresponding to the user's needs. Then, based on the agent information and dependencies between different subtasks, the system sequentially calls the corresponding agents in the agent system to execute the subtasks, obtaining the corresponding execution results. Finally, based on the obtained execution results, the system generates and outputs the response result corresponding to the user's needs. In this way, the user only needs to input fuzzy user needs information, and the system automatically breaks it down into multiple different, independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0105] Furthermore, all agents share a unified data pool containing user-related and execution data, eliminating the need for manual input and reducing repetitive data entry while improving data accuracy. Each subtask can have multiple (e.g., 2-3) backup agents. If the primary agent fails, the system automatically schedules a backup agent to continue execution and pushes progress updates to the user, requiring no manual intervention. This increases task success rate and avoids delays caused by single-tool failures. Users can also customize agent attributes and set scenario-based rules to further improve operational efficiency and adapt to customized processes across different industries.

[0106] like Figure 14As shown in the embodiments of this specification, a task processing method is provided. The execution subject of this method can be a collaborative scheduling subsystem, which can run on a terminal device or a server. The terminal device can be a mobile terminal device such as a mobile phone or tablet computer, or a computer device such as a laptop or desktop computer, or an IoT device (specifically, a smartwatch, in-vehicle device, etc.). The server can be a single server or a server cluster composed of multiple servers. The server can be a backend server for financial or online shopping services, or a backend server for an application. This embodiment uses a server as the execution subject for detailed explanation. For the case where the execution subject is a terminal device, please refer to the following server-side processing, which will not be repeated here. The method may specifically include the following steps: In step S1402, the subtasks corresponding to the user demand information input by the target user and the dependencies between different subtasks are obtained.

[0107] In step S1404, the agent management subsystem is invoked, and based on the capability assessment information of each agent in the agent subsystem provided by the agent management subsystem, the agent information for executing each subtask is determined according to the subtask corresponding to the user requirement information.

[0108] In step S1406, based on the agent information for each subtask and the dependencies between different subtasks, the corresponding agents in the agent system are sequentially invoked to execute the subtasks, and the corresponding execution results are obtained.

[0109] In step S1408, based on the obtained execution results, a response result corresponding to the user's requirement information is generated and output.

[0110] This specification provides a task processing method. It obtains subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it invokes an intelligent agent management subsystem and, based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determines the intelligent agent information to execute each subtask according to the subtask corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, it sequentially invokes the corresponding intelligent agents in the intelligent agent system to execute the subtasks, obtaining the corresponding execution results. Finally, based on the obtained execution results, it generates and outputs the response result corresponding to the user demand information. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, it reconstructs the underlying logic of multi-agent collaboration, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0111] In practical applications, user demand information includes a resource transfer information sheet for the target user. The sub-tasks corresponding to the user demand information include one or more of the following: key information extraction, generating a resource transfer analysis report for a preset time period, extracting the conclusions of the analysis report and generating a presentation, constructing a user profile for the target user, and suggestions for the target user.

[0112] In practical applications, the subtasks corresponding to user demand information include subtask 1, subtask 2, subtask 3, and subtask 4. The dependencies between different subtasks include that after subtask 1 is executed, subtasks 2 and 3 are executed in parallel; after subtasks 2 and 3 are executed, subtask 4 is executed. The agent information for executing each subtask includes agent A executing subtask 1, agent B executing subtask 2, agent C executing subtask 3, and agent D executing subtask 4. Based on this, the specific processing method of step S1406 can be varied. The following provides another optional processing method, which may specifically include the processing of steps S140602 to S140610. Based on this, in the above... Figure 14 Based on this, the specific steps included in this method can be as follows: Figure 15 As shown.

[0113] In step S140602, agent A is invoked to execute subtask 1, and after subtask 1 is completed, the execution result of subtask 1 is stored in the data sharing subsystem 500.

[0114] In step S140604, when it is detected that subtask 1 has been completed, subtask 2 and subtask 3 are triggered to be executed in parallel.

[0115] In step S60606, agent B is invoked to obtain the execution result of subtask 1 from the data sharing subsystem 500, and subtask 2 is executed based on the execution result of subtask 1. At the same time, agent C obtains the execution result of subtask 1 from the data sharing subsystem, and subtask 3 is executed based on the execution result of subtask 1. After subtask 2 and subtask 3 are executed, the execution results of subtask 2 and subtask 3 are stored in the data sharing subsystem 500.

[0116] In step S60608, when it is detected that subtask 2 and subtask 3 have been completed, subtask 4 is triggered to execute.

[0117] In step S60610, the intelligent agent D is invoked to obtain the execution results of subtask 1, subtask 2 and subtask 3 from the data sharing subsystem 500, and based on the execution results of subtask 1, subtask 2 and subtask 3, subtask 4 is executed to obtain the execution result of subtask 4.

[0118] In practical applications, if an exception occurs during the execution of a subtask by the corresponding intelligent agent, it can be handled through the following steps E2 to E6.

[0119] In step E2, it is determined whether there are alternative processing strategies for the subtask that has an anomaly.

[0120] In step E4, if an alternative processing agent exists, the alternative processing agent corresponding to the alternative processing strategy is invoked. Based on the alternative processing strategy, the subtask that caused the exception is re-executed, as well as the subtasks following the subtask that caused the exception are continued to be executed.

[0121] In step E6, if the factor causing the subtask to malfunction is not present, the subtask is repaired, and after the repair is completed, the subtask that malfunctioned is re-executed. After the re-execution is completed, the subtasks following the subtask that malfunctioned are executed.

[0122] This specification provides a task processing method. It obtains subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it invokes an intelligent agent management subsystem and, based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determines the intelligent agent information to execute each subtask according to the subtask corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, it sequentially invokes the corresponding intelligent agents in the intelligent agent system to execute the subtasks, obtaining the corresponding execution results. Finally, based on the obtained execution results, it generates and outputs the response result corresponding to the user demand information. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, it reconstructs the underlying logic of multi-agent collaboration, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0123] Furthermore, all agents share a unified data pool containing user-related and execution data, eliminating the need for manual input and reducing repetitive data entry while improving data accuracy. Each subtask can have multiple (e.g., 2-3) backup agents. If the primary agent fails, the system automatically schedules a backup agent to continue execution and pushes progress updates to the user, requiring no manual intervention. This increases task success rate and avoids delays caused by single-tool failures. Users can also customize agent attributes and set scenario-based rules to further improve operational efficiency and adapt to customized processes across different industries.

[0124] The above describes the task processing method provided in the embodiments of this specification. Based on the same idea, the embodiments of this specification also provide a task processing apparatus, such as... Figure 16 As shown.

[0125] The processing device for this task includes: a task acquisition module 1601, a task and agent matching module 1602, a task execution module 1603, and a demand response module 1604, wherein: The task acquisition module 1601 acquires the sub-tasks corresponding to the user demand information input by the target user, as well as the dependencies between different sub-tasks; The task and agent matching module 1602 calls the agent management subsystem and, based on the capability evaluation information of each agent in the agent subsystem provided by the agent management subsystem, determines the agent information to execute each subtask according to the subtask corresponding to the user demand information. The task execution module 1603 executes the sub-tasks sequentially through the corresponding intelligent agents based on the intelligent agent information for each sub-task and the dependencies between different sub-tasks, thereby obtaining the corresponding execution results; The demand response module 1604 generates and outputs the response result corresponding to the user demand information based on the obtained execution result.

[0126] In the embodiments of this specification, the task execution module 1603 sequentially calls the corresponding intelligent agents in the intelligent agent subsystem to execute the sub-tasks based on the intelligent agent information for each sub-task and the dependencies between different sub-tasks, thereby obtaining the corresponding execution results.

[0127] In this embodiment of the specification, the user demand information includes a resource transfer information sheet for the target user, and the sub-tasks corresponding to the user demand information include one or more of the following: key information extraction, generating a resource transfer analysis report for a preset time period, extracting the conclusions of the analysis report and generating a presentation, constructing a user profile of the target user, and suggestions for the target user.

[0128] In this embodiment of the specification, the subtasks corresponding to the user requirement information include subtask 1, subtask 2, subtask 3, and subtask 4. The dependencies between different subtasks include that after subtask 1 is executed, subtasks 2 and 3 are executed in parallel; after subtasks 2 and 3 are executed, subtask 4 is executed. The agent information for executing each subtask includes agent A executing subtask 1, agent B executing subtask 2, agent C executing subtask 3, and agent D executing subtask 4. The task execution module 1603 includes: The first task execution unit executes the subtask 1 through the intelligent agent A, and after the execution of the subtask 1 is completed, stores the execution result of the subtask 1 in the data sharing subsystem; The first triggering unit, upon detecting the completion of subtask 1 through the collaborative scheduling module, triggers the parallel execution of subtask 2 and subtask 3. The second task execution unit obtains the execution result of subtask 1 from the data sharing subsystem through the intelligent agent B, and executes subtask 2 based on the execution result of subtask 1. At the same time, it obtains the execution result of subtask 1 from the data sharing module through the intelligent agent C, and executes subtask 3 based on the execution result of subtask 1. After the execution of subtask 2 and subtask 3 is completed, the execution results of subtask 2 and subtask 3 are stored in the data sharing subsystem. The second triggering unit, when the collaborative scheduling module detects that subtask 2 and subtask 3 have been completed, triggers the execution of subtask 4. The third task execution unit obtains the execution results of subtask 1, subtask 2 and subtask 3 from the data sharing subsystem through the intelligent agent D, and executes subtask 4 based on the execution results of subtask 1, subtask 2 and subtask 3 to obtain the execution result of subtask 4.

[0129] In this embodiment of the specification, if an exception occurs during the execution of the subtask by the corresponding intelligent agent, the device further includes: The judgment module determines whether there are alternative handling strategies for the subtask that has an anomaly. If an alternative processing module exists, it will re-execute the subtask that encountered the error, and continue to execute the subtasks following the subtask that encountered the error, based on the alternative processing strategy and the alternative processing agent corresponding to the alternative processing strategy. If the repair module is not present, it will repair the factors that caused the subtask to malfunction. After the repair is completed, the subtask that malfunctioned will be re-executed, and after the re-execution is completed, the subtasks following the one that malfunctioned will continue to be executed.

[0130] For ease of description, the above devices are described by dividing them into various modules or units based on their functions. Of course, when implementing one or more embodiments of this specification, the functions of each module or unit can be implemented in one or more software and / or hardware components, or a module that performs the same function can be implemented by a combination of multiple sub-modules or sub-units, etc. The device embodiments described above are merely illustrative; the division of each module and unit is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or modules can be combined or integrated into another system, or some features can be ignored or not executed, etc.

[0131] This specification provides a task processing device that acquires subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it can invoke an intelligent agent management subsystem and, based on the capability evaluation information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determine the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, the subtasks are executed sequentially through the corresponding intelligent agents to obtain the corresponding execution results. Finally, based on the obtained execution results, a response result corresponding to the user demand information can be generated and output. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0132] Furthermore, all agents share a unified data pool containing user-related and execution data, eliminating the need for manual input and reducing repetitive data entry while improving data accuracy. Each subtask can have multiple (e.g., 2-3) backup agents. If the primary agent fails, the system automatically schedules a backup agent to continue execution and pushes progress updates to the user, requiring no manual intervention. This increases task success rate and avoids delays caused by single-tool failures. Users can also customize agent attributes and set scenario-based rules to further improve operational efficiency and adapt to customized processes across different industries.

[0133] The above describes the task processing apparatus provided in the embodiments of this specification. Based on the same concept, the embodiments of this specification also provide a task processing device, such as... Figure 17 As shown.

[0134] The processing device for the task can be a terminal device or a server, as described in the above embodiments.

[0135] The processing device for a task can vary considerably depending on its configuration or performance, and may include a communication interface 1702, a user interface 1704, a processor 1706, and data storage 1708. These components are interconnected and communicate with each other via a system bus, network, or other connection mechanism 1710. The communication interface 1702 enables the processing device 1700 to communicate with other devices, access networks, and transmission networks via analog or digital modulation. For example, the communication interface 1702 may include a chipset and antenna for wireless communication with a radio access network or access point. Furthermore, the communication interface 1702 can be a wired interface such as Ethernet, Token Ring, or a USB port, or a wireless interface such as Wi-Fi, Bluetooth, Global Positioning System (GPS), or a wide-area wireless interface (e.g., WiMAX or LTE). Of course, the communication interface 1702 may also support other forms of physical layer interfaces and standard or proprietary communication protocols. The communication interface 1702 may also include multiple physical communication interfaces, such as Wi-Fi, Bluetooth, and wide-area wireless interfaces.

[0136] User interface 1704 includes receiving user input and providing output to the user. Therefore, user interface 1704 may include input components such as a keypad, keyboard, touch-sensitive or presence-sensitive panel, computer mouse, trackball, joystick, microphone, still camera, and video camera, and output components such as a display screen (which may be combined with a touch-sensitive panel), CRT, LCD, LED, display using DLP technology, printer, and other similar devices known or developed in the future. User interface 1704 may also generate auditory output via speakers, speaker jacks, audio output ports, audio output devices, headphones, and other similar devices known or developed in the future. In some embodiments, user interface 1704 may include software, circuitry, or other forms of logic capable of transmitting and receiving data from external user input / output devices. Additionally or alternatively, task processing device 1700 may support remote access from other devices via communication interface 1702 or another physical interface (not shown). User interface 1704 may be configured to receive user input, the position and movement of which may be indicated by indicators or cursors described herein. User interface 1704 can also be configured as a display device for rendering or displaying text fragments.

[0137] The processor 1706 may contain one or more general-purpose processors and / or special-purpose processors.

[0138] Data storage 1708 may contain one or more volatile and / or non-volatile storage components and may be integrated wholly or partially with processor 1706. Data storage 1708 may contain removable and non-removable components.

[0139] Processor 1706 is capable of executing program instructions 1718 (e.g., compiled or uncompiled program logic and / or machine code) stored in data store 1708 to perform the various functions described herein. Data store 1708 may contain a non-transitory computer-readable medium on which program instructions are stored, which, when executed by processing device 1700 of the task, enable processing device 1700 of the task to perform any methods, processes, or functions disclosed in this specification and / or the accompanying drawings. Processor 1706 executing program instructions 1718 may result in processor 1706 using data 1712.

[0140] For example, program instructions 1718 may include an operating system 1722 (e.g., an operating system kernel, device drivers, and / or other modules) installed on the task's processing device 1700, and one or more applications 1720 (e.g., a browser, social application, or game application). Similarly, data 1712 may include operating system data 1716 and application data 1714. Operating system data 1716 is primarily accessible to the operating system 1722, while application data 1714 is primarily accessible to one or more applications 1720. Application data 1714 may reside in a file system that is either visible or hidden from the user on the task's processing device 1700.

[0141] Application 1720 can communicate with operating system 1712 through one or more application programming interfaces (APIs). These APIs help application 1720 read and / or write application data 1714, transmit or receive information via communication interface 1702, receive or display information on user interface 1704, etc.

[0142] In some terminology, application 1720 may be simply referred to as "app". Furthermore, application 1720 can be downloaded to the task processing device 1700 via one or more online app stores or app markets. However, the application can also be installed on the task processing device 1700 in other ways, such as through a web browser or a physical interface on the task processing device 1700 (e.g., a USB port).

[0143] Specifically, in this embodiment, the task processing device 1700 includes a data storage 1708 and one or more program instructions 1718, wherein one or more program instructions 1718 are stored in the data storage 1708, and one or more program instructions 1718 are configured to be executed by one or more processors. The one or more program instructions include computer-executable instructions for performing the following: Obtain the subtasks corresponding to the user demand information input by the target user, as well as the dependencies between different subtasks; The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the subtasks are executed sequentially by the corresponding agents to obtain the corresponding execution results; Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

[0144] In another specific embodiment, the task processing device 1700 includes a data storage 1708 and one or more program instructions 1718, wherein one or more program instructions 1718 are stored in the data storage 1708, and one or more program instructions 1718 are configured to be executed by one or more processors. The one or more program instructions include computer-executable instructions for performing the following: Obtain the subtasks corresponding to the user demand information input by the target user, as well as the dependencies between different subtasks; The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the corresponding agents in the agent subsystem are sequentially invoked to execute the subtasks, and the corresponding execution results are obtained. Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

[0145] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments for processing the task are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0146] This specification provides a task processing device that acquires subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it can invoke an intelligent agent management subsystem and, based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determine the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, the subtasks are executed sequentially through the corresponding intelligent agents to obtain the corresponding execution results. Finally, based on the obtained execution results, a response result corresponding to the user demand information can be generated and output. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operating costs, and improving fault tolerance.

[0147] Furthermore, based on the above Figure 7 , Figure 8 , Figure 14 and Figure 15 This specification also provides a storage medium for storing computer-executable instruction information in one or more embodiments. In one specific embodiment, the storage medium may be a USB flash drive, optical disc, hard disk, etc. When the computer-executable instruction information stored in the storage medium is executed by a processor, it can realize the following process: Obtain the subtasks corresponding to the user demand information input by the target user, as well as the dependencies between different subtasks; The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the subtasks are executed sequentially by the corresponding agents to obtain the corresponding execution results; Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

[0148] In another specific embodiment, the storage medium can be a USB flash drive, optical disc, hard disk, etc., and the computer-executable instruction information stored in the storage medium can achieve the following process when executed by the processor: Obtain the subtasks corresponding to the user demand information input by the target user, as well as the dependencies between different subtasks; The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the corresponding agents in the agent subsystem are sequentially invoked to execute the subtasks, and the corresponding execution results are obtained. Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

[0149] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the above-described storage medium embodiment is basically similar to the method embodiment, so the description is relatively simple; relevant parts can be referred to the description of the method embodiment.

[0150] This specification provides a storage medium that acquires subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it can invoke an intelligent agent management subsystem and, based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determine the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, the subtasks are executed sequentially through the corresponding intelligent agents to obtain the corresponding execution results. Finally, based on the obtained execution results, a response result corresponding to the user demand information can be generated and output. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0151] Furthermore, based on the above Figure 7 , Figure 8 , Figure 14 and Figure 15 This specification also provides one or more embodiments of a computer program product, including a computer program, which, when executed by a processor, can perform the following processes: Obtain the subtasks corresponding to the user demand information input by the target user, as well as the dependencies between different subtasks; The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the subtasks are executed sequentially by the corresponding agents to obtain the corresponding execution results; Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

[0152] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the above-described embodiment of a computer program product is relatively simple in description because it is fundamentally similar to the method embodiment; relevant parts can be referred to the description of the method embodiment.

[0153] This specification provides a computer program product that acquires subtasks corresponding to user demand information input by a target user, as well as the dependencies between different subtasks. Then, it can invoke an intelligent agent management subsystem and, based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, determine the intelligent agent information to execute each subtask according to the subtasks corresponding to the user demand information. Subsequently, based on the intelligent agent information executing each subtask and the dependencies between different subtasks, the subtasks are executed sequentially through the corresponding intelligent agents to obtain the corresponding execution results. Finally, based on the obtained execution results, a response result corresponding to the user demand information can be generated and output. In this way, the user only needs to input fuzzy user demand information, and the system automatically breaks it down into multiple different independently executable subtasks without requiring manual triggering of any steps, greatly improving operational efficiency. Furthermore, it supports cross-ecosystem intelligent agent collaboration and can handle multi-round closed-loop tasks, thus achieving full-process coverage. In addition, the underlying logic of multi-agent collaboration has been reconstructed, enabling the system to autonomously collaborate with intelligent agents, truly solving the coverage of complex scenarios, reducing operational costs, and improving fault tolerance.

[0154] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps described in the claims may be performed in a different order than those shown in the embodiments and still achieve the desired results. Furthermore, the processes depicted in the drawings do not necessarily require a specific or sequential order to achieve the desired results. In some embodiments, multitasking and parallel processing are possible or may be advantageous. Moreover, although one or more embodiments of this specification provide method steps as described in the embodiments or flowcharts, it is understood that the order of steps listed in the embodiments or flowcharts is merely one possible execution order among many steps and does not represent the only execution order. Therefore, when method steps are involved in the claims, adjustments to the order of those steps, or parallelism between steps, are also within the scope of protection of the claims.

[0155] In the 1990s, improvements to a technology could be clearly distinguished as either hardware improvements (e.g., improvements to the circuit structure of diodes, transistors, switches, etc.) or software improvements (improvements to the methodology). However, with technological advancements, many methodological improvements today can be considered direct improvements to the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved methodology into the hardware circuit. Therefore, it cannot be said that a methodological improvement cannot be implemented using hardware physical modules. For example, a Programmable Logic Device (PLD) (such as a Field Programmable Gate Array (FPGA)) is such an integrated circuit whose logic function is determined by the user programming the device. Designers can program and "integrate" a digital system onto a PLD themselves, without needing chip manufacturers to design and manufacture dedicated integrated circuit chips. Furthermore, nowadays, instead of manually manufacturing integrated circuit chips, this programming is mostly implemented using "logic compiler" software. Similar to the software compiler used in program development, the original code before compilation must also be written in a specific programming language, called a Hardware Description Language (HDL). There are many HDLs, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, and RHDL (Ruby Hardware Description Language). Currently, the most commonly used are VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art should also understand that by simply performing some logic programming on the method flow using one of these hardware description languages ​​and programming it into an integrated circuit, the hardware circuit implementing the logical method flow can be easily obtained.

[0156] The controller can be implemented in any suitable manner. For example, it can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicon Labs C8051F320. A memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also recognize that, in addition to implementing the controller in purely computer-readable program code form, the same functionality can be achieved by logically programming the method steps to make the controller take the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers. Therefore, such a controller can be considered a hardware component, and the means included therein for implementing various functions can also be considered as structures within the hardware component. Alternatively, the means for implementing various functions can be considered as both software modules implementing the method and structures within the hardware component.

[0157] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, a computer can be, for example, a personal computer, laptop computer, cellular phone, camera phone, smartphone, personal digital assistant, media player, navigation device, email device, game console, tablet computer, wearable device, or any combination of these devices.

[0158] For ease of description, the above apparatus is described by dividing it into various functional units. Of course, when implementing one or more embodiments of this specification, the functions of each unit can be implemented in one or more software and / or hardware.

[0159] Those skilled in the art will understand that the embodiments of this specification can be provided as methods, systems, or computer program products. Therefore, one or more embodiments of this specification may take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, one or more embodiments of this specification may take the form of a computer program product implemented on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

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

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

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

[0163] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0164] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0165] Computer-readable media include both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0166] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical or equivalent elements in the process, method, article, or apparatus that includes said element. Furthermore, "a," "an," and "the" are not specifically singular and may include plural forms. Ordinal numbers such as "first," "second," etc., do not necessarily indicate order; they are often used to distinguish objects. For example, "first server" and "second server" usually refer to two servers, described as "first server" and "second server" to differentiate them; however, sometimes these two servers may be the same server. Moreover, in this specification, unless explicitly stated otherwise, "receiving and sending data" does not necessarily mean direct receiving and sending; it can be indirect receiving and sending (i.e., receiving and sending indirectly through one or more entities). Similarly, in this specification, unless otherwise stated, the relationships between structures can be direct or indirect.

[0167] Furthermore, the specific terms used in this specification to describe embodiments, such as "an embodiment," "one embodiment," or "some embodiments," refer to a particular feature, structure, or characteristic related to at least one embodiment of this specification. Therefore, it should be emphasized and noted that "an embodiment," "one embodiment," or "an alternative embodiment" mentioned twice or more in different locations in this specification do not necessarily refer to the same embodiment. Moreover, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of those different embodiments or examples, without contradiction.

[0168] Those skilled in the art will understand that the embodiments of this specification can be provided as methods, systems, or computer program products. Therefore, one or more embodiments of this specification may take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, one or more embodiments of this specification may take the form of a computer program product implemented on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0169] One or more embodiments of this specification can be described in the general context of computer-executable instructions, such as program modules, that are executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform a specific task or implement a specific abstract data type. One or more embodiments of this specification can also be practiced in distributed computing environments where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer storage media, including storage devices.

[0170] 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 describing the differences from other embodiments. In particular, the system embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments.

[0171] The above description is merely an embodiment of this specification and is not intended to limit this document. Various modifications and variations can be made to this specification by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this specification should be included within the scope of the claims in this document.

Claims

1. A method for processing a task, the method comprising: Obtain the subtasks corresponding to the user demand information input by the target user, as well as the dependencies between different subtasks; The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the subtasks are executed sequentially by the corresponding agents to obtain the corresponding execution results; Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

2. The method according to claim 1, wherein the user demand information includes a resource transfer information sheet for the target user, and the sub-tasks corresponding to the user demand information include one or more of the following: key information extraction, generating a resource transfer analysis report for a preset time period, extracting the conclusions of the analysis report to generate a presentation, constructing a user profile of the target user, and suggestions for the target user.

3. The method according to claim 1 or 2, wherein the subtasks corresponding to the user demand information include subtask 1, subtask 2, subtask 3, and subtask 4, and the dependencies between different subtasks include that after subtask 1 is executed, subtasks 2 and 3 are executed in parallel, and after subtasks 2 and 3 are executed, subtask 4 is executed; the agent information for executing each subtask includes agent A executing subtask 1, agent B executing subtask 2, agent C executing subtask 3, and agent D executing subtask 4; and the step of executing the subtasks sequentially through the corresponding agents according to the agent information for executing each subtask and the dependencies between different subtasks to obtain the corresponding execution results includes: The agent A executes the subtask 1, and after the subtask 1 is completed, the execution result of the subtask 1 is stored in the data sharing subsystem. When the collaborative scheduling module detects that subtask 1 has been completed, it triggers subtask 2 and subtask 3 to be executed in parallel. The execution result of subtask 1 is obtained from the data sharing subsystem by the intelligent agent B, and subtask 2 is executed based on the execution result of subtask 1. At the same time, the execution result of subtask 1 is obtained from the data sharing module by the intelligent agent C, and subtask 3 is executed based on the execution result of subtask 1. After the execution of subtask 2 and subtask 3 is completed, the execution results of subtask 2 and subtask 3 are stored in the data sharing subsystem. When the collaborative scheduling module detects that subtask 2 and subtask 3 have been completed, it triggers the execution of subtask 4. The agent D obtains the execution results of subtask 1, subtask 2 and subtask 3 from the data sharing subsystem, and executes subtask 4 based on the execution results of subtask 1, subtask 2 and subtask 3 to obtain the execution result of subtask 4.

4. The method according to claim 3, wherein if an exception occurs during the execution of the subtask by the corresponding intelligent agent, the method further comprises: Determine if there are alternative handling strategies for the subtask that has encountered an anomaly; If they exist, the alternative processing agent corresponding to the alternative processing strategy will re-execute the subtask that caused the error, and continue to execute the subtasks after the subtask that caused the error, based on the alternative processing strategy. If it does not exist, the factors that caused the subtask to malfunction will be repaired. After the repair is completed, the subtask that malfunctioned will be re-executed. After the re-execution is completed, the subtasks following the one that malfunctioned will continue to be executed.

5. A task processing system, the system comprising a user interaction subsystem, an agent management subsystem, and an agent subsystem, wherein: The agent management subsystem is configured to perform capability assessments on each agent in the agent subsystem and determine the capability assessment information of each agent in the agent subsystem. The user interaction subsystem is configured to receive user demand information input by the target user, parse the user demand information, determine the sub-tasks corresponding to the user demand information, and the dependencies between different sub-tasks. The intelligent agent subsystem is configured to obtain subtasks corresponding to user demand information input by the target user from the user interaction subsystem, as well as the dependencies between different subtasks. The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the subtasks are executed sequentially by the corresponding agents to obtain the corresponding execution results; Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

6. The system according to claim 5, wherein the user interaction subsystem comprises a requirement parsing unit and a task decomposition unit, wherein: The requirement parsing unit is configured to extract information from the user requirement information to obtain key information corresponding to the user requirement information. The key information includes one or more of the user requirement objectives and constraints. The task decomposition unit is configured to generate sub-tasks corresponding to the user requirement information and the dependencies between different sub-tasks based on the key information corresponding to the user requirement information.

7. The system according to claim 5, further comprising a data sharing subsystem. The data sharing subsystem is configured to store the execution results of different subtasks and provide corresponding data for the execution of each subtask.

8. The system according to claim 5, wherein the intelligent agent subsystem comprises a cooperative scheduling module and a multi-agent module, wherein the multi-agent module is configured with a variety of different intelligent agents; The collaborative scheduling module is configured to obtain subtasks corresponding to user demand information input by the target user, as well as the dependencies between different subtasks. The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the multi-agent module provided by the intelligent agent management subsystem, the intelligent agent information for executing each sub-task is determined according to the sub-task corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the corresponding agents are invoked sequentially to execute the subtasks and obtain the corresponding execution results. Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

9. A task processing system, the system comprising a user interaction subsystem, an agent management subsystem, a cooperative scheduling subsystem, and an agent subsystem, wherein the agent subsystem comprises multiple different agents, wherein: The agent management subsystem is configured to perform capability assessments on each agent in the agent subsystem and determine the capability assessment information of each agent in the agent subsystem. The user interaction subsystem is configured to receive user demand information input by the target user, parse the user demand information, determine the sub-tasks corresponding to the user demand information, and the dependencies between different sub-tasks. The collaborative scheduling subsystem is configured to obtain subtasks corresponding to user demand information input by the target user from the user interaction subsystem, as well as the dependencies between different subtasks. The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the corresponding agents are invoked sequentially to execute the subtasks and obtain the corresponding execution results. Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

10. The system according to claim 9, further comprising a data sharing subsystem. The data sharing subsystem is configured to store the execution results of different subtasks and provide corresponding data for the execution of each subtask.

11. A task processing apparatus, the apparatus comprising: The task acquisition module retrieves the subtasks corresponding to the user requirements information input by the target user, as well as the dependencies between different subtasks; The task and agent matching module calls the agent management subsystem and, based on the capability assessment information of each agent in the agent subsystem provided by the agent management subsystem, determines the agent information to execute each subtask according to the subtask corresponding to the user demand information. The task execution module executes the sub-tasks sequentially through the corresponding agents based on the agent information for each sub-task and the dependencies between different sub-tasks, and obtains the corresponding execution results. The demand response module generates and outputs the response result corresponding to the user demand information based on the obtained execution result.

12. A task processing apparatus, the task processing apparatus comprising: processor; as well as A memory configured to store computer-executable instructions, which, when executed, cause the processor to: Obtain the subtasks corresponding to the user demand information input by the target user, as well as the dependencies between different subtasks; The intelligent agent management subsystem is invoked, and based on the capability assessment information of each intelligent agent in the intelligent agent subsystem provided by the intelligent agent management subsystem, the intelligent agent information for executing each subtask is determined according to the subtask corresponding to the user demand information. Based on the agent information for each subtask and the dependencies between different subtasks, the subtasks are executed sequentially by the corresponding agents to obtain the corresponding execution results; Based on the obtained execution results, the response results corresponding to the user's requirement information are generated and output.

Images