Intelligent agent execution method, device, and storage medium

Abstract

The application discloses an agent execution method and device and a storage medium, relates to the technical field of artificial intelligence, and is applied to an agent execution system. The agent execution system is connected with multiple executors respectively. Each executor is an integrated packaging unit of an agent and a first application relied on by the agent when the agent executes a task. The method comprises the following steps: in response to a cross-application task instruction, a cross-application task in the cross-application task instruction is decomposed to obtain a task execution sequence. The task execution sequence comprises multiple subtasks in sequence. According to the task execution sequence, target executors matched with the subtasks are called from the executors in sequence, and the target executors are controlled to execute the corresponding subtasks in sequence. Based on the subtask execution results fed back by the target executors, the task execution result of the cross-application task is determined. The application can improve the data security in a host computer on the basis of guaranteeing the cross-application operation capability of an agent.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a method, device and storage medium for executing intelligent agents. Background Technology

[0002] With the development of artificial intelligence technology, AI agents capable of autonomously executing complex tasks are gradually being applied to multi-scenario and cross-application operations.

[0003] Currently, when AI agents (especially computer-based agents) perform cross-application tasks, they typically need to access the entire screen display of the host machine to perceive, operate, and interact with different application interfaces in order to identify interface elements, parse operational logic, and complete cross-application processes. However, this approach allows AI agents to indiscriminately access all information presented on the host machine screen, including but not limited to sensitive content such as financial account information, login passwords, private chat logs, personal identification data, and trade secrets, posing significant data security and privacy risks.

[0004] Therefore, how to improve data security on the host machine while ensuring the cross-application operation capability of intelligent agents is an urgent problem to be solved. Summary of the Invention

[0005] The main purpose of this application is to provide an intelligent agent execution method, device and storage medium, which aims to improve data security in the host machine while ensuring the cross-application operation capability of the intelligent agent.

[0006] To achieve the above objectives, this application provides an agent execution method applied to an agent execution system. The agent execution system is connected to multiple executors, each of which is an integrated encapsulation unit for an agent and a first application on which the agent depends when performing a task. The agent execution method includes:

[0007] In response to a cross-application task instruction, the cross-application task in the cross-application task instruction is decomposed to obtain a task execution sequence, wherein the task execution sequence includes multiple ordered subtasks; According to the task execution sequence, the target executor matched by each subtask is called sequentially from each of the executors, and each target executor is controlled to execute the corresponding subtask in sequence; Based on the subtask execution results fed back by each target executor, the task execution result of the cross-application task is determined.

[0008] In one embodiment, the step of sequentially calling the target executor matched to each subtask from each of the executors according to the task execution sequence, and sequentially controlling each target executor to execute the corresponding subtask, includes: The first unexecuted target subtask in the task execution sequence is identified, the target executor matching the target subtask is called from each of the executors, and the target agent in the target executor is controlled to execute the target subtask. Obtain the subtask execution results fed back by the target executor, and determine whether there are any unexecuted subtasks in the task execution sequence; If so, return to the step of determining the first unexecuted target subtask in the task execution sequence; If not, then the step of determining the task execution result of the cross-application task based on the subtask execution results fed back by each of the target executors is executed.

[0009] In one embodiment, the step of invoking the target executor matching the target subtask from each of the executors includes: Determine the second application that the target subtask depends on and the task type of the target subtask; From the executors, select the executor that encapsulates the second application and the intelligent agent that supports the task type, as the target executor for matching the target subtask.

[0010] In one embodiment, the step of controlling the target agent in the target executor to execute the target sub-task includes: Determine whether the target subtask has a data source requirement; If it exists, then obtain the data source requirements of the target subtask, and determine the target execution result that meets the data source requirements from the execution results of the subtasks that have been executed; The target execution result is sent to the target executor, and the target agent in the target executor is controlled to execute the target sub-task based on the target execution result.

[0011] In one embodiment, the intelligent agent execution system includes an orchestrator connected to each of the executors via a message bus. Each executor subscribes to a command topic in the message bus and is authorized to publish data to a data topic in the message bus. The command topics and data topics of each executor are different. The orchestrator is authorized to issue commands to the respective command topics of each of the executors. The step of sending the target execution result to the target executor and controlling the target agent in the target executor to execute the target subtask according to the target execution result includes: The orchestrator encapsulates the target execution result into a task execution command and publishes the task execution command to the command topic subscribed to by the target executor. The orchestrator subscribes to the respective data topics of each of the executors, and the step of obtaining the subtask execution results fed back by the target executor includes: The orchestrator receives the subtask execution results published by the target executor to the data topic corresponding to the target executor.

[0012] In one embodiment, the actuator is an isolation container, and a first application in the actuator runs in a virtual display environment within the isolation container. The step of controlling the target agent in the target actuator to execute the target sub-task includes: Control the target agent in the target executor to execute the target subtask in the target application within the target executor.

[0013] In one embodiment, the actuator is an isolation container, and a first application in the actuator runs in a virtual display environment within the isolation container. The step of controlling the target agent in the target actuator to execute the target sub-task includes: Control the target agent in the target executor to execute the target subtask in the target application within the target executor.

[0014] In one embodiment, the orchestrator is a planning agent built based on a large language model, and the step of decomposing the cross-application tasks in the cross-application task instructions to obtain the task execution sequence includes: The cross-application task is obtained by parsing the cross-application task instructions through the orchestrator; The cross-application task is decomposed into sub-tasks, and a task execution sequence is generated based on the dependencies between the sub-tasks.

[0015] In one embodiment, the agent execution system further includes a security policy module embedded in a message bus. After the step of controlling the target agent in the target executor to execute the target subtask, the method further includes: The security policy module receives the subtask execution results published by the target executor to the message bus, and a screenshot of the container display within the target executor. Malicious payload determination is performed on the execution results of the subtasks and the screenshot of the container display to obtain the determination result; If the determination result indicates the presence of a malicious payload, output a prompt or return to the step of controlling the target agent in the target actuator to execute the target sub-task; If the determination result indicates that there is no malicious payload, the step of obtaining the subtask execution result fed back by the target executor is executed.

[0016] Furthermore, to achieve the above objectives, this application also provides an intelligent agent execution device, which is applied to an intelligent agent execution system. The intelligent agent execution system is connected to multiple actuators, each of which is an integrated encapsulation unit of an intelligent agent and a first application on which the intelligent agent depends when performing a task. The intelligent agent execution device includes: An orchestration module is used to respond to a cross-application task instruction, decompose the cross-application task in the cross-application task instruction, and obtain a task execution sequence, wherein the task execution sequence includes multiple ordered subtasks; The scheduling module is used to sequentially call the target executor matched by each subtask from each of the executors according to the task execution sequence, and sequentially control each of the target executors to execute the corresponding subtask; The determination module determines the task execution result of the cross-application task based on the subtask execution results fed back by each target executor.

[0017] In addition, to achieve the above objectives, this application also proposes an electronic device, the device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the intelligent agent execution method as described above.

[0018] In addition, to achieve the above objectives, this application also provides a storage medium, which is a computer-readable storage medium, on which a program implementing an intelligent agent execution method is stored, and the program implementing the intelligent agent execution method is executed by a processor to implement the steps of the intelligent agent execution method as described above.

[0019] In addition, to achieve the above objectives, this application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the intelligent agent execution method as described above.

[0020] This application provides an intelligent agent execution method. This method is applied to an intelligent agent execution system, which is connected to multiple preset executors. Each executor is an integrated encapsulation unit of an intelligent agent and a first application on which the intelligent agent depends when performing a task. First, in response to a cross-application task instruction, the cross-application task in the instruction is decomposed to obtain a task execution sequence, which includes multiple ordered sub-tasks. Then, according to the task execution sequence, the target executor matching each sub-task is sequentially called from each executor, and each target executor is sequentially controlled to execute its corresponding sub-task. Finally, based on the sub-task execution results fed back by each target executor, the task execution result of the cross-application task is determined.

[0021] In summary, this application uses an integrated encapsulation unit of the intelligent agent and the application it relies on for task execution as the executor. This confines each application's operation to its dedicated execution unit, effectively preventing the intelligent agent from indiscriminately accessing the host machine's global screen content and reducing the risk of sensitive information leakage at the source. Simultaneously, in response to cross-application task instructions, this application decomposes cross-application tasks into multiple ordered sub-tasks, enabling modular and controllable execution of cross-application tasks and facilitating precise matching of corresponding target executors. By sequentially calling the target executors matched to each sub-task according to the task execution sequence and controlling their execution, combined with the federated isolated execution architecture formed by these executors, each sub-task executes independently and securely without interference, completing application interactions without relying on the host machine's global screen awareness. Finally, the overall execution result of the cross-application task is determined based on the sub-task execution results fed back by each target executor, achieving a collaborative closed loop for each modular task and ensuring efficient implementation of cross-application tasks. Thus, compared to traditional agent invocation methods that cannot simultaneously guarantee cross-application capabilities and host data security, this application, while ensuring the agent's cross-application operation capabilities and the orderly and efficient completion of cross-application tasks, fundamentally blocks the path of sensitive information leakage, significantly improves the host's data security and privacy protection level, and reduces data security risks. Attached Figure Description

[0022] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0023] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0024] Figure 1 This is a flowchart illustrating the first embodiment of the intelligent agent execution method of this application; Figure 2 This is a schematic diagram of the system architecture involved in one embodiment of the intelligent agent execution method of this application; Figure 3 This is a schematic diagram of the intelligent agent execution process according to an embodiment of the intelligent agent execution method of this application; Figure 4 This is a schematic diagram of the module structure of the intelligent agent execution device of this application; Figure 5 This is a schematic diagram of the device structure of the hardware operating environment involved in the intelligent agent execution method in the embodiments of this application.

[0025] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0026] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.

[0027] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0028] Currently, energy storage systems are typically designed using materials with good thermal conductivity to enhance their heat dissipation capabilities, or they rely solely on cooling fans, radiators, or coolants for heat dissipation. However, these methods are relatively inefficient and limited in their approach, failing to effectively cool complex intelligent agent execution systems and thus impacting their overall cooling efficiency. Therefore, improving data security within the host machine while ensuring the cross-application operational capabilities of intelligent agents is a pressing issue that needs to be addressed.

[0029] The main solution of this application is as follows: In response to a cross-application task instruction, the cross-application task in the cross-application task instruction is decomposed to obtain a task execution sequence, wherein the task execution sequence includes multiple ordered sub-tasks; according to the task execution sequence, the target executor matched by each sub-task is sequentially called from each of the executors, and each target executor is sequentially controlled to execute the corresponding sub-task; based on the sub-task execution results fed back by each target executor, the task execution result of the cross-application task is determined.

[0030] This application uses an integrated encapsulation unit, consisting of the intelligent agent and the application it relies on for task execution, as the executor. This confines each application's operation to its dedicated execution unit, effectively preventing the intelligent agent from indiscriminately accessing the host machine's global screen content and reducing the risk of sensitive information leakage at the source. Simultaneously, in response to cross-application task instructions, this application decomposes cross-application tasks into multiple ordered sub-tasks, enabling modular and controllable execution and facilitating precise matching of corresponding target executors. By sequentially calling the target executors matched to each sub-task according to the task execution sequence and controlling their execution, combined with the federated isolated execution architecture formed by these executors, each sub-task executes independently and securely without interference, completing application interactions without relying on the host machine's global screen awareness. Finally, the overall execution result of the cross-application task is determined based on the sub-task execution results fed back by each target executor, achieving a collaborative closed loop for each modular task and ensuring efficient implementation of cross-application tasks. Thus, compared to traditional agent invocation methods that cannot simultaneously guarantee cross-application capabilities and host data security, this application, while ensuring the agent's cross-application operation capabilities and the orderly and efficient completion of cross-application tasks, fundamentally blocks the path of sensitive information leakage, significantly improves the host's data security and privacy protection level, and reduces data security risks.

[0031] It should be noted that the execution subject of the method in the various embodiments of the intelligent agent execution method of this application can be an intelligent agent execution system, or a computing service device with data processing, network communication, and program execution functions, such as a tablet computer, personal computer, mobile phone, etc., or an intelligent agent execution device capable of realizing the above functions, etc. This embodiment does not specifically limit it in this way. This application specifically relates to AI intelligent agent architecture, computer use of intelligent agents, network security, zero trust architecture, and distributed systems. The following uses an intelligent agent execution system as the execution subject as an example to describe this embodiment and the following embodiments.

[0032] Based on this, this application proposes a first embodiment of an intelligent agent execution method, which is applied to an intelligent agent execution system. The intelligent agent execution system is connected to multiple executors, and each executor is an integrated encapsulation unit for an intelligent agent and a first application that the intelligent agent depends on when performing a task. Please refer to... Figure 1 The intelligent agent execution method includes steps S10 to S30: Step S10: In response to the cross-application task instruction, decompose the cross-application task in the cross-application task instruction to obtain a task execution sequence, wherein the task execution sequence includes multiple ordered sub-tasks; It should be noted that the agent execution system is responsible for decomposing cross-application tasks, invoking executors, and summarizing task results. It establishes connections with multiple executors to achieve collaborative management and control, serving as the core support for ensuring the orderly and secure execution of cross-application tasks. The executor is the core unit for achieving secure and isolated execution. Each executor is an integrated encapsulation unit of an agent and the application it depends on when executing tasks (hereinafter referred to as the first application for distinction). This can be understood as each unit being an independent, physically isolated runtime environment (e.g., a Docker container). The agent is a CUA (Computer-Using Agent) agent responsible for executing specific task operations; its actions and perception scope are strictly limited to the container it resides in. The first application is the application that the agent depends on when executing the corresponding task. This integrated encapsulation isolates application operations from the external environment, preventing the agent from accessing irrelevant sensitive information. The aforementioned agent execution system and each executor run on the host operating system, presenting a decoupled federated architecture that provides physical isolation protection to the host machine itself. Cross-application task instructions refer to task instructions initiated by users or external systems that require the cooperation of multiple different applications to complete.

[0033] Upon receiving a cross-application task instruction, the cross-application task in the instruction is parsed to clarify the overall requirements of the task and the applications it depends on. Then, based on the task requirements and the functional boundaries of each application, the cross-application task is decomposed into multiple independent subtasks. At the same time, based on the dependencies between the subtasks, the multiple subtasks are arranged in an orderly manner to form a task execution sequence.

[0034] Through the above process, complex cross-application tasks can be broken down into simple, independently executable subtasks, reducing the difficulty of task execution. At the same time, it lays the foundation for accurate invocation of the target executor and orderly execution of subtasks, avoiding execution chaos caused by the complexity of cross-application tasks.

[0035] In this embodiment, the intelligent agent execution system includes an orchestrator, which is a planning intelligent agent built based on a large language model. Step S10 may include: Step S101: The cross-application task instruction is parsed by the orchestrator to obtain the cross-application task; Step S102: Decompose the cross-application task into sub-tasks, and generate a task execution sequence based on the dependencies between the sub-tasks.

[0036] It's important to note that the intelligent agent execution system includes an orchestrator, which acts as the central planner and the system's "brain." This orchestrator is responsible for macro-level planning and workflow scheduling. Furthermore, it lacks GUI (Graphical User Interface) operation capabilities and visual perception on the host machine. At its core is a planning agent based on a Large Language Model (LLM). The LLM's "tools / functions" do not include GUI operations like click or type; instead, they consist of "API calls" (such as `call_chrome_worker(task)`) representing various isolated execution units. This design allows for precise connection to each isolated executor, achieving scheduling and control without a GUI. As the core control carrier for achieving modular and orderly execution of cross-application tasks, the orchestrator is responsible for the core functions of receiving high-level user instructions, parsing cross-application task instructions, decomposing cross-application tasks and generating task execution sequences, and maintaining workflow status. Among them, the core advantage of the planning agent is that it relies on the semantic understanding and logical planning capabilities of the large language model to accurately capture the core needs of high-level user instructions (such as "execute quarterly report"), efficiently sort out the dependencies between sub-tasks, and ensure the rationality of task decomposition, the orderliness of task execution sequence, and the smoothness of workflow scheduling.

[0037] In response to cross-application task instructions, the orchestrator, leveraging LLM semantic understanding capabilities, parses the instructions and extracts core requirements to obtain the cross-application tasks. Then, utilizing LLM planning capabilities, these cross-application tasks are decomposed into multiple subtasks. Based on the dependencies between these subtasks, a Directed Acyclic Graph (DAG) or a sequence of steps—the aforementioned task execution sequence—is generated. Furthermore, the orchestrator is responsible for maintaining the workflow state; for example, Task_A is pending processing, and Task_B depends on the processing result of Task_A.

[0038] For example, taking "execute quarterly report" as a high-level user instruction, the orchestrator first receives the instruction and, relying on the semantic understanding capabilities of a large language model, parses the core requirement of the instruction as "complete the data summary, data analysis, and report generation for this quarter," clarifying that it involves applications such as Excel, data analysis tools, and document editing tools, thus obtaining a clear cross-application task. Subsequently, relying on LLM planning capabilities, the cross-application task is broken down into three independent sub-tasks: "extract core data for this quarter from Excel," "perform statistical analysis on the extracted data using data analysis tools," and "generate a quarterly report using document editing tools based on the analysis results." The sub-task dependencies are then identified—data extraction is completed first, followed by data analysis, and finally, the report is generated. The task execution sequence is then arranged in this order, while maintaining the workflow status as "sub-task 1 pending, sub-task 2 depends on sub-task 1, and sub-task 3 depends on sub-task 2."

[0039] Step S20: According to the task execution sequence, sequentially call the target executor matched by each subtask from each executor, and sequentially control each target executor to execute the corresponding subtask; According to the task execution sequence, the executor matching each subtask is called sequentially from each executor (hereinafter referred to as the target executor for distinction), and after determining the target executor corresponding to the first subtask to be executed, the target executor is controlled to execute the current subtask.

[0040] In this embodiment, step S20 may include: Step S201: Determine the first unexecuted target subtask in the task execution sequence, call the target executor matching the target subtask from each of the executors, and control the target agent in the target executor to execute the target subtask; Identify the first unexecuted subtask (hereinafter referred to as the target subtask for distinction) in the workflow (i.e. task execution sequence) maintained by the orchestrator, call the target executor that matches the target subtask from each executor, and control the agent in the target executor (hereinafter referred to as the target agent for distinction) to execute the current target subtask.

[0041] Step S202: Obtain the subtask execution result fed back by the target executor, and determine whether there are any unexecuted subtasks in the task execution sequence; The orchestrator obtains the subtask execution results fed back by the target executor, indicating that the target subtask has been completed, updates the task execution sequence, and determines whether there are any unexecuted subtasks in the updated task execution sequence.

[0042] Step S203: If yes, then return to the step of determining the first unexecuted target subtask in the task execution sequence; If there are unexecuted subtasks in the latest task execution sequence, then the first unexecuted target subtask in the task execution sequence is determined, the executor matching the determined target subtask is executed in a loop, and the process of executing the target subtask by the executor is controlled until all subtasks in the task execution sequence are executed.

[0043] Step S204: If not, then execute the step of determining the task execution result of the cross-application task based on the subtask execution results fed back by each of the target executors.

[0044] If there are no unexecuted subtasks in the latest task execution sequence, then the step of determining the task execution result across applications is performed based on the subtask execution results fed back by each target executor.

[0045] In this embodiment, step S201 may include: Step A10: Determine the second application that the target subtask depends on and the task type of the target subtask; It should be noted that the application that the target subtask depends on during its execution is referred to as the second application for distinction. The task type is the specific operational attribute of the target subtask (such as data extraction, statistical analysis, report generation, etc.). The agent must have the operational capability to support the corresponding task type. The executor must simultaneously meet two conditions: encapsulating the corresponding second application and having internal agents that support the corresponding task type, in order to serve as the target executor for matching the target subtask. The invocation of the filtering process relies on the orchestrator's planning capabilities.

[0046] Step A20: Select, from among the executors, the executor that encapsulates the second application and the intelligent agent that supports the task type, as the target executor for matching the target subtask.

[0047] First, clarify the core requirements of the target subtask and determine the second application and specific task type it depends on. Then, using these two conditions as screening criteria, filter from all executors connected to the system, and select executors that simultaneously encapsulate the second application and whose internal agents support the task type. These executors are then identified as the target executors that match the target subtask, laying the foundation for the execution of subsequent target subtasks and ensuring that the subtasks can be successfully implemented with the help of the corresponding application and agents.

[0048] For example, taking the task execution sequence of "execute a quarterly report" as an example, the explicit order of the task execution sequence is "data extraction → data analysis → report generation". First, the first target sub-task "extracting core data for this quarter from Excel" is advanced. An executor that encapsulates Excel and supports data extraction tasks is selected as the target executor. The orchestrator controls the internal agent of the target executor to complete the core data extraction operation for this quarter using Excel. After the target sub-task is completed, the second target sub-task "data analysis" is advanced according to the sequence. A target executor that encapsulates data analysis tools and supports statistical analysis tasks is selected, and execution instructions are sent to control its internal agent to carry out data analysis. This process continues in the same manner. Finally, the target executor that encapsulates document editing tools is called to control the agent to generate the quarterly report. The entire process strictly follows the task execution sequence, completing the invocation and control of the three target executors in sequence. Each executor independently completes its corresponding sub-task. The agent only operates within its own executor and does not access the global information of the host machine, which ensures both the orderliness of execution and data security.

[0049] Step S30: Based on the subtask execution results fed back by each target executor, determine the task execution result of the cross-application task.

[0050] After all subtasks in the task execution sequence have been completed and their results have been fed back to the intelligent agent execution system, the nature of the current cross-application task is determined. If the task requires the collaborative support of multiple subtasks (such as a quarterly report), the results of multiple subtasks are aggregated and integrated as the final task execution result. If the task is executed sequentially and the final goal only requires the completion of the last subtask (such as "open a document and fill in the content"), the final result can directly adopt the execution result of the last subtask. After completing the entire task flow, the final result can be fed back to the user to ensure that the task execution effectiveness is traceable and verifiable.

[0051] It's important to note that AI agents aim to autonomously operate computers to complete complex tasks, with their core value lying in "autonomy." However, this introduces risks to the host operating system (HOS) and its data. The action risk arises when the agent, due to "illusion" or malicious commands, performs erroneous actions (such as deleting files or making malicious clicks), resulting in irreversible damage. The data risk stems from the fact that, to perform cross-application tasks, the agent must "see" all screen content on the host machine, granting it indiscriminate access to all confidential information and posing a significant privacy breach risk.

[0052] Thus, this application embodiment sets an integrated encapsulation unit for the intelligent agent and the application it relies on when executing tasks as the executor, so that the operation of each application is confined within a dedicated execution unit, effectively preventing the intelligent agent from indiscriminately accessing the global screen content of the host machine, reducing the risk of sensitive information leakage from the source; at the same time, this application responds to cross-application task instructions by decomposing cross-application tasks into multiple ordered sub-tasks, so that cross-application tasks can be executed in a modular and controllable manner, making it easy to accurately match the corresponding target executor; by sequentially calling the target executor matched to each sub-task according to the task execution sequence and controlling its execution of the corresponding sub-task, combined with the federated isolated execution architecture formed by each executor, each sub-task can be executed independently and securely without interfering with each other, and can complete application interaction without relying on the global screen perception of the host machine; finally, the overall execution result of the cross-application task is determined based on the sub-task execution results fed back by each target executor, realizing the collaborative closed loop of each modular task and ensuring the efficient implementation of cross-application tasks. Thus, compared to traditional agent invocation methods that cannot simultaneously guarantee cross-application capabilities and host data security, this application, while ensuring the agent's cross-application operation capabilities and the orderly and efficient completion of cross-application tasks, fundamentally blocks the path of sensitive information leakage, significantly improves the host's data security and privacy protection level, and reduces data security risks.

[0053] Based on the first embodiment of this application, in the second embodiment of this application, the content that is the same as or similar to that in the first embodiment described above can be referred to the above description and will not be repeated hereafter. Based on this, step S201 may include: Step B10: Determine whether the target subtask has a data source requirement; It should be noted that data source requirements refer to the preceding data support that the task relies on during execution.

[0054] Based on the task execution sequence maintained by the orchestrator, the data dependencies of each subtask are determined. If there is no data dependency, it means that the current subtask does not have a data source requirement, such as the first subtask in the task execution sequence; if there is a data dependency, it means that the current subtask has a data source requirement.

[0055] Step B20: If it exists, obtain the data source requirement of the target subtask, and determine the target execution result that meets the data source requirement from the execution results of the subtasks that have been executed. If the target subtask has a data source requirement, obtain the data source requirement of the target subtask, and select the execution result that meets the data source requirement from the execution results of the already executed subtasks (hereinafter referred to as the target execution result for distinction).

[0056] Step B30: Send the target execution result to the target executor, and control the target agent in the target executor to execute the target subtask according to the target execution result.

[0057] The target execution result is sent to the current target executor, and the target agent in the target executor is controlled to execute the target sub-task based on the target execution result.

[0058] For example, taking the task execution sequence of "execute quarterly report" (data extraction → data analysis → report generation) as an example, the specific implementation process is as follows: For the second target sub-task "data analysis", first determine whether the target sub-task has a data source requirement (relying on the result of the first sub-task "data extraction"); then clarify that the data source requirement of the target sub-task is "core Excel data of this quarter"; from the execution results of the already executed "data extraction" sub-task, determine the target execution result that meets the requirement (i.e., the extracted core Excel data); send the target execution result to the target executor corresponding to data analysis, and finally control the target agent in the executor to complete the data analysis sub-task based on the received data and its own encapsulated data analysis tools; if the target sub-task has no data source requirement (such as the first "data extraction" sub-task), then directly control the target agent to perform the data extraction operation based on Excel, without needing to obtain the preceding data.

[0059] In this embodiment, the orchestrator is connected to each of the executors via a message bus. Each executor subscribes to a command topic in the message bus and is authorized to publish data to a data topic in the message bus. The command topics and data topics of each executor are different. The orchestrator is authorized to publish commands to the respective command topics of each executor. Step B30 may include: Step C10: The orchestrator encapsulates the target execution result into a task execution command and publishes the task execution command to the command topic subscribed to by the target executor; It's important to note that the orchestrator connects to each executor via a message bus, also known as the communication bus. This message bus is the system's only asynchronous communication channel and is essentially a controlled message queue (Message Broker), such as RabbitMQ, Kafka, or Redis Pub / Sub, handling all command and data transmission between the orchestrator and the executors. The system employs a topic-based publish / subscribe (Pub / Sub) model. Each executor subscribes to a command topic and is authorized to publish data to a data topic. Each executor subscribes to a different command topic and is also authorized to publish data to a different data topic. Direct communication between any two executors is not allowed. Furthermore, the orchestrator, acting as the message bus intermediary, is authorized to publish commands to each executor's respective command topic.

[0060] The orchestrator encapsulates the target execution results that the target subtask depends on into a task execution command, and publishes the task execution command to the command topic subscribed to by the target executor. After receiving the command, the target executor executes the target subtask by its internal target agent based on the target execution results.

[0061] For example, the task execution command can be a structured JSON command, such as {"task_id":"...","worker_id":"CUA_A","payload":"..."}, where "task_id" represents the task identifier, "worker_id" represents the executor identifier, and "payload" represents the data that the current task depends on (equivalent to the target execution result).

[0062] The orchestrator subscribes to the respective data topics of each of the executors, and step S202 may include: Step C20: Receive the subtask execution results published by the target executor to the data topic corresponding to the target executor through the orchestrator.

[0063] It should be noted that the encoder subscribes to the data topics corresponding to all executors in order to receive the subtask execution results published by each executor.

[0064] After the target executor completes the task, it publishes the subtask execution results to its own dedicated data topic. The orchestrator receives the subtask execution results and updates the workflow status by subscribing to this data topic.

[0065] For example, taking the task execution sequence of "Executing a Quarterly Report" (data extraction → data analysis → report generation) and its corresponding executors (CUA_A: data extraction, CUA_B: data analysis, CUA_C: report generation) as an example, and combining it with the specific implementation of the message bus mechanism: First, the message bus uses RabbitMQ as the message queue, and assigns unique command topics and data topics to the three executors respectively—CUA_A subscribes to cmd.worker.A and authorizes publishing to data.result.A, CUA_B subscribes to cmd.worker.B and authorizes publishing to data.result.B, and CUA_C subscribes to cmd.worker.C and authorizes publishing to data.result.C; the orchestrator is authorized to publish commands to the three command topics cmd.worker.A, cmd.worker.B, and cmd.worker.C, and simultaneously subscribes to the three data topics data.result.A, data.result.B, and data.result.C. When executing the "Data Analysis" subtask (the subtask corresponding to CUA_B) and a data source is required, the orchestrator first receives the execution result of the "Data Extraction" subtask from the data topic CUA_A published to data.result.A (the subscription has been completed and the workflow status has been updated). It then encapsulates this result (the core Excel data for this quarter) into a task execution command and publishes this command to the command topic cmd.worker.B subscribed to by CUA_B. CUA_B receives the task execution command by subscribing to this command topic, extracts the data payload, and its internal target agent uses this data and its own encapsulated data analysis tools to complete the data analysis subtask. After CUA_B completes execution, it publishes the data analysis result to its authorized data topic data.result.B. The orchestrator receives the subtask execution result by subscribing to this topic, updates the workflow status, and triggers the "Report Generation" subtask. This process repeats, encapsulating the data analysis result into a command and publishing it to the cmd.worker.C topic of CUA_C, until the entire task is completed. Throughout the process, CUA_A, CUA_B, and CUA_C do not communicate directly with each other. All command transmissions and data exchanges are asynchronously mediated by the orchestrator through the message bus, ensuring the orderliness, security, and independence of communication.

[0066] Thus, this application transforms the uncontrollable and high-risk "action permission" problem into a controllable and classic "data flow security" problem, evolving from an unpredictable "black box" into a manageable "white box" distributed system, solving the problem of the difficulty in defending against the "action risk" of intelligent agents. Simultaneously, the orchestrator, acting as the scheduling center, is only responsible for planning and communication, lacking GUI vision or keyboard and mouse operation capabilities, greatly reducing its "explosion radius" after being compromised. The executor is only responsible for execution and cannot obtain or manipulate any information outside the container. In summary, by transmitting structured data through the communication bus, cross-application workflows are realized, and all cross-application interactions become transparent, auditable, and controllable. This application's intelligent agent execution method can be widely applied in fields with extremely high security and privacy requirements, such as finance (automatic reporting), healthcare (cross-system data extraction), and legal affairs (document processing).

[0067] In this embodiment, the actuator is an isolated container, and the first application in the actuator runs in a virtual display environment within the isolated container. Step S201 may include: Step B40: Control the target agent in the target executor to execute the target subtask in the target application within the target executor.

[0068] It's important to note that each executor is an isolated container. The application within the executor is the application to be automated (such as Chrome or Excel), running in a virtual display environment within the container. This virtual reality environment can be VNC (Virtual Network Computing) or Xvfb (X Virtual Framebuffer). The intelligent agent within the executor cannot physically access or manipulate the application within it, nor can it access the host machine's screen, files, or processes.

[0069] Thus, this application embodiment ensures both the accuracy of subtask execution and environmental security by judging the data source requirements of subtasks, accurately transmitting the target execution results, and setting the executor as an isolated container, allowing the agent to execute subtasks in a virtual display environment within the container. The communication mechanism provides secure and asynchronous communication support for the implementation of the corresponding execution control method through the topic publish / subscribe mechanism of the message bus and the authorization control of the orchestrator, realizing orderly interaction between the orchestrator and each executor and avoiding the risk of direct interaction. The combination of these three aspects not only ensures the orderly and efficient execution process of the agent, but also comprehensively improves the security and reliability of system execution through parallel protection and subordinate support, ensuring the accurate implementation of cross-application tasks.

[0070] Based on the first and second embodiments of this application, in the third embodiment of this application, the content that is the same as or similar to the first and second embodiments described above can be referred to the above description and will not be repeated hereafter. In addition, the intelligent agent execution system further includes a security policy module, which is embedded in the message bus. After step S201, the intelligent agent execution method of this application further includes: Step C10: Receive the subtask execution result published by the target executor to the message bus and the container display screenshot within the target executor through the security policy module; It should be noted that the security policy module is the core security component of the intelligent agent execution system, embedded in the message bus (communication bus). It acts as a "security checkpoint" to achieve zero-trust security control, and its core responsibilities include identity authentication and access control, data cleansing, and malicious payload detection. Identity authentication and access control (IAM) requires each component connected to the bus (orchestrator, executor) to use a unique credential for authentication. This unique credential can be a TLS (Transport Layer Security) certificate or an Access Token. The container display screenshot is a screenshot of the virtual display environment operation interface within the container, taken after the target executor (isolated container) completes the target sub-task, used to assist in identifying malicious operations. Malicious payloads refer to malicious data or instructions that may pose a system risk, such as CSV (Comma-Separated Values) injection or SQL (Structured Query Language) injection.

[0071] The security policy module receives the subtask execution results published by the target executor to its corresponding data topic, as well as screenshots of the containers within the target executor.

[0072] Step C20: Perform malicious payload determination on the subtask execution result and the container display screenshot to obtain the determination result; After the security policy module detects the container display screenshot and the subtask execution result, it checks whether the container display screenshot is normal (e.g., whether the system has been tampered with) and whether the data format in the subtask execution result is normal. If either of these does not meet the requirements, it is determined to be a malicious payload, and the determination result is that a malicious payload exists.

[0073] Step C30: If the determination result indicates the existence of a malicious payload, output a prompt or return to the step of controlling the target agent in the target executor to execute the target sub-task; If the determination result indicates the presence of a malicious payload, an error message will be output to inform of the abnormal situation, or the current payload will be cleaned, and the execution control target actuator will return to the step of executing the target sub-task, that is, the sub-task will be executed again to avoid false detection.

[0074] Step C40: If the determination result indicates that there is no malicious payload, perform the step of obtaining the subtask execution result fed back by the target executor.

[0075] If the determination result is that there is no malicious payload, the step of obtaining the subtask execution result fed back by the target executor is directly executed. That is, the security policy module does not perform any subtask execution result, and the orchestrator is allowed to obtain the subtask execution result from the message bus.

[0076] For example, such as Figure 2 The diagram shows the system architecture. First, each executor and agent execution system runs on the host operating system. The agent execution system includes an orchestrator, a security policy module, and a controlled data channel. The orchestrator communicates with each executor via a message bus. The security policy module and controlled data channel are embedded in the message bus. The security policy module is used for authentication and access control, malicious payload detection, and data cleansing. The controlled data channel includes multiple command topics and data topics, serving as the key basis for communication between the orchestrator and each executor. Executor A includes an agent CUA_A and an application APP_A, and executor B includes an agent CUA_B and an application APP_B. Within the executor, the agent can be controlled via a GUI within the application. In this way, the host machine receives physical isolation protection from the isolated container. The user issues instructions to the orchestrator, which receives the instructions, breaks down the task, and sends task execution instructions to the executors via the message bus. Upon receiving the task execution instructions, the executors operate the application within the container and send the output data (task execution results) to the controlled data channel via the message bus. The data stream is cleaned and authenticated by the security policy module before being acquired by the orchestrator to execute the next cross-application task. Crucially, the two executors cannot communicate or act directly with each other, and cannot access the host machine's screen or files.

[0077] In one feasible implementation, such as Figure 3The diagram illustrates the agent execution flow. First, the user sends a cross-application task instruction to the orchestrator. Upon receiving the instruction, the orchestrator decomposes the cross-application task and maintains the workflow. The tasks to be executed in the workflow include Task_1 and Task_2, with Task_2 depending on the execution result of Task_1. The two tasks are executed by containers A and B respectively. The execution command for Task_1 is first published to command topic 1 of the message bus (a command topic subscribed to by container A). Container A retrieves the execution command for Task_1 from the message bus and executes Task_1 internally, obtaining task execution result 1. This result 1 is then published to its authorized data topic. Security policy. The module first receives task execution result 1 and performs verification such as malicious payload detection and data cleaning on it. After verification and cleaning are completed, the processed task execution result 1 is given to the orchestrator. The orchestrator encapsulates task execution result 1 into the task execution command of Task_2 and publishes it to command topic 2 subscribed to by container B. Container B receives the command with task execution result 1 from the message bus and executes Task_2 based on the task execution result to obtain task execution result 2. Similarly, task execution result 2 of Task_2 is passed through the security policy module and given to the orchestrator. Finally, the orchestrator determines the final result based on the task execution results of the two subtasks and feeds it back to the user.

[0078] Thus, this embodiment of the application embeds the security policy module into the message bus. After the target subtask is executed, it performs dual malicious payload judgment on the subtask execution result and the container display screenshot published by the target executor, realizing proactive security verification of the subtask execution result. Differentiated processing is adopted for the judgment result. When a malicious payload is present, a prompt is output in time or the subtask is re-executed to prevent malicious data from flowing into subsequent processes. When no malicious payload is present, the result acquisition step is advanced. This not only fills the security gap in the message transmission and result feedback links and strengthens the zero-trust security protection capability of the system, but also ensures the security and effectiveness of the subtask execution result, ensures the stability and reliability of the intelligent agent execution process, and further improves the security protection level of the entire system.

[0079] This application also provides an intelligent agent execution device, please refer to... Figure 4 The intelligent agent execution device is applied to an intelligent agent execution system, which is connected to multiple actuators. Each actuator is an integrated encapsulation unit for an intelligent agent and a first application that the intelligent agent depends on when performing a task. The intelligent agent execution device includes: The orchestration module 10 is used to respond to a cross-application task instruction, decompose the cross-application task in the cross-application task instruction, and obtain a task execution sequence, wherein the task execution sequence includes multiple ordered sub-tasks; The scheduling module 20 is used to sequentially call the target executor matched by each subtask from each of the executors according to the task execution sequence, and sequentially control each target executor to execute the corresponding subtask. The determination module 30 determines the task execution result of the cross-application task based on the subtask execution results fed back by each target executor.

[0080] Optionally, the scheduling module 20 is further configured to: The first unexecuted target subtask in the task execution sequence is identified, the target executor matching the target subtask is called from each of the executors, and the target agent in the target executor is controlled to execute the target subtask. Obtain the subtask execution results fed back by the target executor, and determine whether there are any unexecuted subtasks in the task execution sequence; If so, return to the step of determining the first unexecuted target subtask in the task execution sequence; If not, then the step of determining the task execution result of the cross-application task based on the subtask execution results fed back by each of the target executors is executed.

[0081] Optionally, the scheduling module 20 is further configured to: Determine the second application that the target subtask depends on and the task type of the target subtask; From the executors, select the executor that encapsulates the second application and the intelligent agent that supports the task type, as the target executor for matching the target subtask.

[0082] Optionally, the scheduling module 20 is further configured to: Determine whether the target subtask has a data source requirement; If it exists, then obtain the data source requirements of the target subtask, and determine the target execution result that meets the data source requirements from the execution results of the subtasks that have been executed; The target execution result is sent to the target executor, and the target agent in the target executor is controlled to execute the target sub-task based on the target execution result.

[0083] Optionally, the intelligent agent execution system includes an orchestrator connected to each of the executors via a message bus. Each executor subscribes to a command topic in the message bus and is authorized to publish data to a data topic in the message bus. The command topics and data topics of each executor are different. The orchestrator is authorized to issue commands to the respective command topics of each of the executors, and the scheduling module 20 is further configured to: The orchestrator encapsulates the target execution result into a task execution command and publishes the task execution command to the command topic subscribed to by the target executor. The orchestrator subscribes to the respective data topics of each of the executors, and the scheduling module 20 is further configured to: The orchestrator receives the subtask execution results published by the target executor to the data topic corresponding to the target executor.

[0084] Optionally, the actuator is an isolated container, and the first application in the actuator runs in a virtual display environment within the isolated container. The scheduling module 20 is further configured to: Control the target agent in the target executor to execute the target subtask in the target application within the target executor.

[0085] Optionally, the orchestrator is a planning agent built based on a large language model, and the orchestration module 10 is further used for: The cross-application task is obtained by parsing the cross-application task instructions through the orchestrator; The cross-application task is decomposed into sub-tasks, and a task execution sequence is generated based on the dependencies between the sub-tasks.

[0086] Optionally, the intelligent agent execution system further includes a security policy module embedded in the message bus, and the intelligent agent execution device further includes a security module, which is used for: The security policy module receives the subtask execution results published by the target executor to the message bus, and a screenshot of the container display within the target executor. Malicious payload determination is performed on the execution results of the subtasks and the screenshot of the container display to obtain the determination result; If the determination result indicates the presence of a malicious payload, output a prompt or return to the step of controlling the target agent in the target actuator to execute the target sub-task; If the determination result indicates that there is no malicious payload, the step of obtaining the subtask execution result fed back by the target executor is executed.

[0087] The intelligent agent execution device provided in this application, employing the intelligent agent execution method described in the above embodiments, can solve the technical problem of how to improve data security in the host machine while ensuring the cross-application operation capability of the intelligent agent. Compared with the prior art, the beneficial effects of the intelligent agent execution device provided in this application are the same as those of the intelligent agent execution method provided in the above embodiments, and other technical features in the intelligent agent execution device are the same as those disclosed in the methods of the above embodiments, and will not be repeated here.

[0088] This application provides an intelligent agent execution device, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the intelligent agent execution method in the first embodiment described above.

[0089] The following is for reference. Figure 5 The diagram illustrates a structural schematic of an intelligent agent execution device suitable for implementing embodiments of this application. The intelligent agent execution device in the embodiments of this application may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Description), PMPs (Portable Media Players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs and desktop computers. Figure 5 The intelligent agent execution device shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0090] like Figure 5 As shown, the intelligent agent execution device may include a processing unit 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory 1002 or a program loaded from a storage device 1003 into a random access memory 1004. The random access memory 1004 also stores various programs and data required for the operation of the intelligent agent execution device. The processing unit 1001, the read-only memory 1002, and the random access memory 1004 are interconnected via a bus 1005. An input / output interface 1006 is also connected to the bus. Typically, the following systems can be connected to the input / output interface 1006: input devices 1007 including, for example, a touchscreen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage devices 1003 including, for example, magnetic tape, hard disk, etc.; and communication devices 1009. The communication device 1009 allows the intelligent agent execution device to communicate wirelessly or wiredly with other devices to exchange data. Although the figure shows intelligent agent execution devices with various systems, it should be understood that it is not required to implement or possess all of the systems shown. More or fewer systems may be implemented alternatively.

[0091] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from read-only memory 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0092] The intelligent agent execution device provided in this application, employing the intelligent agent execution method in the above embodiments, can solve the technical problem of how to improve data security in the host machine while ensuring the cross-application operation capability of the intelligent agent. Compared with the prior art, the beneficial effects of the intelligent agent execution device provided in this application are the same as those of the intelligent agent execution method provided in the above embodiments, and other technical features in this intelligent agent execution device are the same as those disclosed in the previous embodiment method, and will not be repeated here.

[0093] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.

[0094] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0095] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, which are used to execute the agent execution method in the above embodiments.

[0096] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems or devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0097] The aforementioned computer-readable storage medium may be included in the intelligent agent execution device; or it may exist independently and not assembled into the intelligent agent execution device.

[0098] The aforementioned computer-readable storage medium carries one or more programs. When the one or more programs are executed by an intelligent agent execution device, the intelligent agent execution device: responds to a cross-application task instruction, decomposes the cross-application task in the cross-application task instruction to obtain a task execution sequence, wherein the task execution sequence includes multiple ordered subtasks; according to the task execution sequence, sequentially calls the target executor matched to each subtask from each executor, and sequentially controls each target executor to execute the corresponding subtask; and determines the task execution result of the cross-application task based on the subtask execution results fed back by each target executor.

[0099] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0100] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0101] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0102] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., computer programs) for executing the above-described intelligent agent execution method. This addresses the technical problem of improving data security in the host machine while ensuring the cross-application operation capability of the intelligent agent. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the intelligent agent execution method provided in the above embodiments, and will not be elaborated upon here.

[0103] This application provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the intelligent agent execution method described above.

[0104] The computer program product provided in this application can enhance data security in the host machine while ensuring the cross-application operation capability of the intelligent agent. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as the beneficial effects of the intelligent agent execution method provided in the above embodiments, and will not be repeated here.

[0105] The above are merely preferred embodiments of this application and do not limit the patent scope of this application. Any equivalent structural or procedural transformations made using the content of this application's specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent scope of this application.

Claims

1. A method for executing an intelligent agent, characterized in that, The agent execution method is applied to an agent execution system, which is connected to multiple executors. Each executor is an integrated encapsulation unit for the agent and a first application that the agent depends on when performing a task. The agent execution method includes: In response to a cross-application task instruction, the cross-application task in the cross-application task instruction is decomposed to obtain a task execution sequence, wherein the task execution sequence includes multiple ordered subtasks; According to the task execution sequence, the target executor matched by each subtask is called sequentially from each of the executors, and each target executor is controlled to execute the corresponding subtask in sequence; Based on the subtask execution results fed back by each target executor, the task execution result of the cross-application task is determined.

2. The agent execution method as described in claim 1, characterized in that, The step of sequentially calling the target executor matching each subtask from each of the executors according to the task execution sequence, and sequentially controlling each target executor to execute the corresponding subtask, includes: The first unexecuted target subtask in the task execution sequence is identified, the target executor matching the target subtask is called from each of the executors, and the target agent in the target executor is controlled to execute the target subtask. Obtain the subtask execution results fed back by the target executor, and determine whether there are any unexecuted subtasks in the task execution sequence; If so, return to the step of determining the first unexecuted target subtask in the task execution sequence; If not, then the step of determining the task execution result of the cross-application task based on the subtask execution results fed back by each of the target executors is executed.

3. The agent execution method as described in claim 2, characterized in that, The step of calling the target executor matching the target subtask from each of the executors includes: Determine the second application that the target subtask depends on and the task type of the target subtask; From the executors, select the executor that encapsulates the second application and the intelligent agent that supports the task type, as the target executor for matching the target subtask.

4. The agent execution method as described in claim 2, characterized in that, The step of controlling the target agent in the target executor to execute the target sub-task includes: Determine whether the target subtask has a data source requirement; If it exists, then obtain the data source requirements of the target subtask, and determine the target execution result that meets the data source requirements from the execution results of the subtasks that have been executed; The target execution result is sent to the target executor, and the target agent in the target executor is controlled to execute the target sub-task based on the target execution result.

5. The agent execution method as described in claim 4, characterized in that, The intelligent agent execution system includes an orchestrator, which is connected to each of the executors via a message bus. Each executor subscribes to a command topic in the message bus and is authorized to publish data to a data topic in the message bus. The command topics and data topics of each executor are different. The orchestrator is authorized to issue commands to the respective command topics of each of the executors. The step of sending the target execution result to the target executor and controlling the target agent in the target executor to execute the target subtask according to the target execution result includes: The orchestrator encapsulates the target execution result into a task execution command and publishes the task execution command to the command topic subscribed to by the target executor. The orchestrator subscribes to the respective data topics of each of the executors, and the step of obtaining the subtask execution results fed back by the target executor includes: The orchestrator receives the subtask execution results published by the target executor to the data topic corresponding to the target executor.

6. The agent execution method as described in claim 2, characterized in that, The actuator is an isolated container, and the first application in the actuator runs in a virtual display environment within the isolated container. The step of controlling the target agent in the target actuator to execute the target sub-task includes: Control the target agent in the target executor to execute the target subtask in the target application within the target executor.

7. The agent execution method as described in claim 5, characterized in that, The orchestrator is a planning agent built based on a large language model. The step of decomposing the cross-application tasks in the cross-application task instructions to obtain the task execution sequence includes: The cross-application task is obtained by parsing the cross-application task instructions through the orchestrator; The cross-application task is decomposed into sub-tasks, and a task execution sequence is generated based on the dependencies between the sub-tasks.

8. The agent execution method according to any one of claims 2 to 7, characterized in that, The intelligent agent execution system further includes a security policy module embedded in the message bus. After the step of controlling the target intelligent agent in the target executor to execute the target sub-task, the method further includes: The security policy module receives the subtask execution results published by the target executor to the message bus, and a screenshot of the container display within the target executor. Malicious payload determination is performed on the execution results of the subtasks and the screenshot of the container display to obtain the determination result; If the determination result indicates the presence of a malicious payload, output a prompt or return to the step of controlling the target agent in the target actuator to execute the target sub-task; If the determination result indicates that there is no malicious payload, the step of obtaining the subtask execution result fed back by the target executor is executed.

9. An intelligent agent execution device, characterized in that, The intelligent agent execution device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the intelligent agent execution method as described in any one of claims 1 to 8.

10. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, it implements the steps of the agent execution method as described in any one of claims 1 to 8.

Images