An agent code-free task orchestration method, system, device and medium

Abstract

The application relates to an intelligent agent code-free task arrangement method, system, device and medium, which comprises the following steps: receiving a natural language instruction input by a user, acquiring dynamic knowledge related to the semantic of the natural language instruction, performing a timeliness verification operation on the dynamic knowledge, and generating an instruction-knowledge association set; performing semantic analysis on the instruction-knowledge association set, extracting a core intention and a key entity, performing a task disassembly operation based on the core intention and the key entity, and generating a subtask set; based on the subtask set, matching a target intelligent agent from a pre-constructed intelligent agent capability library to obtain an intelligent agent matching result; based on the intelligent agent matching result, generating an intelligent agent collaboration process; performing a file conversion operation on the intelligent agent collaboration process to obtain a standardized process description file; and outputting the standardized process description file to a visual interface for user confirmation. The application has the effect of improving the collaborative execution efficiency of intelligent agent arrangement.

Description

Technical Field

[0001] This application relates to the technical field of natural language processing and agent scheduling, and in particular to an agent no-code task orchestration method, system, device and medium. Background Technology

[0002] Currently, with the widespread application of multi-agent systems in enterprise process automation, more and more users hope to quickly configure tasks and drive multiple agents to execute collaboratively through natural language, thereby achieving flexible business process automation. However, most existing no-code platforms are still stuck in the stage of static component drag-and-drop or rule template configuration, lacking the ability to accurately understand natural language intent and intelligently invoke dynamic knowledge, resulting in a heavy task configuration process, high error rate, and difficulty in reuse.

[0003] Existing intelligent agent scheduling schemes typically rely on predefined task flows and manually set execution paths, lacking an automatic parsing and verification mechanism for key entities, contextual knowledge, and execution constraints in natural language input, making it difficult to meet dynamically changing business needs.

[0004] The existing technical solutions mentioned above have the following drawbacks: the existing intelligent agent task orchestration mechanism lacks the ability to understand the semantics of natural language instructions and associate them with dynamic knowledge. It cannot adjust the task flow and intelligent agent matching logic in a timely manner according to the updated information of the scenario, resulting in the lack of context adaptability and collaborative consistency in the execution behavior of the intelligent agent. Therefore, there is room for improvement. Summary of the Invention

[0005] To improve the collaborative execution efficiency of intelligent agent orchestration, this application provides an intelligent agent no-code task orchestration method, system, device, and medium.

[0006] The above-mentioned objective of this application is achieved through the following technical solution:

[0007] A no-code task orchestration method for intelligent agents, the no-code task orchestration method for intelligent agents comprising:

[0008] Receive natural language instructions input by the user, acquire dynamic knowledge related to the semantics of the natural language instructions, perform timeliness verification on the dynamic knowledge, and generate an instruction-knowledge association set;

[0009] Semantic parsing is performed on the instruction-knowledge association set to extract the core intent and key entities. Based on the core intent and key entities, task decomposition operations are performed to generate a set of subtasks and establish the dependency relationships between the subtasks in the set of subtasks.

[0010] Based on the set of subtasks, target agents are matched from the pre-built agent capability library to obtain agent matching results;

[0011] Based on the dependencies between the subtasks and the matching results of the agent, an agent collaboration process is generated.

[0012] A file conversion operation is performed on the intelligent agent collaborative process to obtain a standardized process description file. The standardized process description file is then output to a visual interface for user confirmation, and the intelligent agent execution process is triggered after user confirmation.

[0013] By adopting the above technical solutions, and by receiving natural language commands input by users and acquiring relevant dynamic knowledge, it is possible to flexibly express user business intentions and comprehensively acquire contextual information, thereby improving the intelligent understanding capability of task orchestration. By performing timeliness verification operations on dynamic knowledge, knowledge content with validity in the current scenario can be filtered out, thereby avoiding outdated information from interfering with task logic. By decomposing tasks based on core intentions and key entities and building dependencies, complex business requirements can be transformed into a structured and executable sub-task system, thereby enhancing the clarity of task orchestration hierarchy and the rationality of execution order. By matching target intelligent agents from the capability library and generating intelligent agent collaboration processes, efficient adaptation and collaborative execution of tasks and executors can be achieved, thereby improving task implementation efficiency. By performing file conversion operations and presenting the process in a standardized form to a visual interface, it is possible to enhance users' understanding and confirmation of the process, thereby improving the transparency and controllability of the system.

[0014] In one example, this application can be further configured as follows: receiving natural language instructions input by the user, acquiring dynamic knowledge related to the semantics of the natural language instructions, performing timeliness verification on the dynamic knowledge, and generating an instruction-knowledge association set, specifically including:

[0015] The system receives natural language commands input by the user through a visual interactive interface. These natural language commands are business expressions without format restrictions.

[0016] All dynamic information in the current scene is obtained, and based on a preset semantic matching algorithm, knowledge content related to the semantics of the natural language instruction is filtered from all dynamic information in the current scene as dynamic knowledge related to the semantics of the natural language instruction.

[0017] Based on preset knowledge time survival tag rules, the timeliness verification operation is performed on the dynamic knowledge to generate the instruction-knowledge association set.

[0018] By adopting the above technical solutions, and receiving user natural language commands through a visual interactive interface, the user operation threshold can be reduced and the interactivity improved, making it suitable for no-code application scenarios for non-professional developers. By acquiring all dynamic information in the current scenario and performing semantic matching, a context-sensitive knowledge acquisition mechanism can be realized, thereby enhancing the task orchestration's responsiveness to real-time business data. By performing timeliness verification based on knowledge time survival tag rules, the usable and correct knowledge used can be guaranteed to be available in the current scenario, thereby improving the reliability of task reasoning.

[0019] In one example, this application can be further configured as follows: the timeliness verification operation is performed on the dynamic knowledge based on the preset knowledge time survival tag rules to generate the instruction-knowledge association set, specifically including:

[0020] Obtain business scenario characteristics, and based on the business scenario characteristics, generate a corresponding dynamic timeliness threshold for each piece of dynamic knowledge. The business scenario characteristics include scenario correction factor, knowledge type coefficient, business process cycle and update frequency.

[0021] Obtain the current time information, and calculate the difference between the timestamp of each piece of dynamic knowledge and the current time information to obtain the existing time of each piece of dynamic knowledge;

[0022] The existing time is compared with the corresponding dynamic time-sensitivity threshold. If the existing time does not exceed the corresponding dynamic time-sensitivity threshold, the corresponding dynamic knowledge is determined to be valid knowledge.

[0023] All valid dynamic knowledge is semantically associated with the corresponding natural language instructions input by the user to generate the instruction-knowledge association set.

[0024] By adopting the above technical solutions, personalized dynamic timeliness thresholds can be generated for dynamic knowledge based on business scenario characteristics, enabling scenario-sensitive control of knowledge validity periods and avoiding misjudgments caused by general threshold settings. By calculating the difference between the knowledge timestamp and the current time, the existence period of knowledge can be accurately determined, thereby improving the accuracy of timeliness judgment in knowledge screening. By comparing the existence time with the timeliness threshold to screen effective knowledge and establishing semantic associations with natural language instructions, it can be ensured that the knowledge used in task orchestration is both timely and semantically relevant, thereby improving the accuracy of task construction.

[0025] In one example, this application can be further configured as follows: semantic parsing of the instruction-knowledge association set to extract core intents and key entities, performing task decomposition operations based on the core intents and key entities to generate a set of subtasks, and establishing dependencies between the subtasks in the set of subtasks, specifically including:

[0026] Based on the intent recognition algorithm, the user's core intent is extracted from the instruction-knowledge association set;

[0027] The key entities in the instruction-knowledge association set are identified by an entity recognition algorithm. The key entities include core entities, business parameters, and constraints.

[0028] Based on the core intent, the key entities, and the valid knowledge content in the instruction-knowledge association set, a task decomposition operation is performed to generate the sub-task set;

[0029] Identify the dependencies between subtasks in the set of subtasks and construct a task dependency graph. The dependencies include sequential dependencies, parallel dependencies, and conditional dependencies.

[0030] By adopting the above technical solutions, the core user intent can be extracted using intent recognition algorithms, thus clarifying the user's true business goals and providing a clear direction for task decomposition. Key entities can be identified using entity recognition algorithms, accurately obtaining task parameters and constraint boundaries, thereby supporting the reasonable setting of subsequent task execution conditions. By combining core intent, key entities, and effective knowledge content to perform task decomposition operations, high-level business requirements can be transformed into a detailed set of sub-tasks, thereby standardizing the task processing flow. Furthermore, by constructing a task dependency graph to identify sequential, parallel, and conditional dependencies, the logical coherence of sub-tasks during execution can be ensured, thereby improving the effectiveness and stability of process scheduling.

[0031] In one example, this application can be further configured as follows: The step of matching target agents from a pre-built agent capability library based on the subtask set to obtain agent matching results specifically includes:

[0032] For each subtask in the set of subtasks, the task capability requirements are extracted to obtain the task capability requirements of each subtask. The task capability requirements include the task target type, input and output parameter characteristics and processing constraints.

[0033] Based on the task capability requirement description, the corresponding candidate agents are retrieved from the pre-built agent capability library;

[0034] Based on the preset semantic matching algorithm and capability adaptation calculation rules, the target intelligent agent for each sub-task is determined from the candidate intelligent agents;

[0035] The target agents of each subtask are combined to construct an agent collaboration combination, and the agent matching result is obtained.

[0036] By adopting the above technical solutions, the task capability requirements of each subtask can be extracted, and its required execution logic and resource parameters can be accurately described, thus providing a clear basis for agent matching. By retrieving candidate agents from the agent capability library, execution units with potential capability matching can be quickly located, thereby improving matching efficiency. By determining the target agent through semantic matching and capability suitability calculation, the relevance and feasibility of the matching results can be enhanced, thereby increasing the success rate of task completion. By constructing agent collaborative combinations, capability synergy among multiple agents in complex tasks can be achieved, thereby supporting intelligent process execution in highly complex scenarios.

[0037] In one example, this application can be further configured such that: the agent-based no-code task orchestration method further includes:

[0038] When there are multiple feasible agent collaboration combinations, the agent collaboration combinations are scored based on a preset collaboration evaluation algorithm to obtain a score result;

[0039] Based on the scoring results, the optimal agent collaboration group is selected from the multiple feasible agent collaboration combinations as the agent matching result.

[0040] Based on the optimal agent cooperation combination, the cooperation compatibility characteristics of each target agent in the optimal agent cooperation combination are obtained. The cooperation compatibility characteristics include interface description information, resource requirement information and execution constraint information.

[0041] A Bayesian logistic regression model was used to pre-identify conflicts in the cooperative compatibility features, and the conflict identification results were obtained.

[0042] If the conflict identification result indicates that a conflict has been identified, the optimal agent cooperation combination will be adjusted according to the preset conflict handling strategy.

[0043] If the conflict identification result is that no conflict is identified, then the optimal agent cooperation combination is output as the agent matching result.

[0044] By adopting the above technical solutions, and by evaluating and scoring collaboration when multiple feasible agent collaboration combinations exist, the execution effect can be comprehensively judged from multiple dimensions, thereby achieving the selection of the optimal solution. By obtaining the collaboration compatibility characteristics of the target agents in the optimal combination, the coordination of interfaces, resources, and constraints among the agents can be analyzed, thereby identifying potential conflict risks in advance. By using a conflict pre-identification based on a Bayesian logistic regression model, the compatibility of collaboration combinations can be intelligently judged using statistical inference methods, thereby reducing the collaboration failure rate. By performing adjustments when conflicts are identified and directly outputting results when no conflicts are identified, the dynamic optimization and stable output of the agent orchestration process can be achieved, thereby ensuring the robustness of the final task process.

[0045] In one example, this application can be further configured as follows: the generation of an agent collaboration process based on the dependency relationships between the subtasks and the matching results of the agent specifically includes:

[0046] Based on the dependencies between subtasks in the subtask set and the agent matching results, an initial agent collaboration process is constructed.

[0047] Based on the current business scenario, obtain business consensus logic rules, which include process sequence specifications, intelligent agent interaction rules, and knowledge usage paths;

[0048] The initial intelligent agent collaboration process is compared with the business consensus logic rules, and a logic consistency check is performed to determine whether there is an execution order, data transmission method or knowledge call path in the initial intelligent agent collaboration process that is inconsistent with the business specifications.

[0049] If the verification fails, the initial intelligent agent collaboration process is adjusted according to the preset process optimization strategy. The process optimization strategy includes reordering subtasks, replacing conflicting intelligent agents, or adjusting the information transmission logic.

[0050] If automatic repair is not possible, optimization suggestions will be generated and the user will be prompted for confirmation.

[0051] The intelligent agent collaboration process that has passed logical verification or been confirmed by the user will be output as the final intelligent agent collaboration process.

[0052] By adopting the above technical solutions, and constructing an initial intelligent agent collaborative process based on sub-task dependencies and intelligent agent matching results, the contextual consistency of process logic and the integrity of execution paths can be guaranteed, thereby improving the executability of task flows. By acquiring business consensus logic rules and performing process consistency verification, it can be ensured that the generated intelligent agent process conforms to industry standards and enterprise specifications, thereby improving the standardization of process implementation. Through automatic identification of logical conflicts and adjustment of process optimization strategies, self-repair of orchestration logic can be achieved, thereby reducing the number of user interventions. By generating optimization suggestions and having them confirmed by the user when repair is not possible, the transparency of interaction between the system and the user can be enhanced, thereby ensuring the flexibility and credibility of business execution.

[0053] The second objective of this invention is achieved through the following technical solution:

[0054] A no-code task orchestration system for intelligent agents, the no-code task orchestration system for intelligent agents comprising:

[0055] The knowledge association module is used to receive natural language instructions input by the user, obtain dynamic knowledge related to the semantics of the natural language instructions, perform timeliness verification on the dynamic knowledge, and generate an instruction-knowledge association set.

[0056] The task decomposition module is used to perform semantic parsing on the instruction-knowledge association set, extract the core intent and key entities, perform task decomposition operations based on the core intent and key entities, generate a set of subtasks, and establish the dependency relationship between each subtask in the set of subtasks.

[0057] The agent matching module is used to match target agents from a pre-built agent capability library based on the subtask set, and obtain agent matching results;

[0058] The process construction module is used to generate an intelligent agent collaborative process based on the dependency relationship between the sub-tasks and the matching result of the intelligent agent;

[0059] The process conversion module is used to perform file conversion operations on the intelligent agent collaborative process to obtain a standardized process description file, output the standardized process description file to the visual interface for user confirmation, and trigger the intelligent agent to execute the process after user confirmation.

[0060] By adopting the above technical solutions, and by receiving natural language commands input by users and acquiring relevant dynamic knowledge, it is possible to flexibly express user business intentions and comprehensively acquire contextual information, thereby improving the intelligent understanding capability of task orchestration. By performing timeliness verification operations on dynamic knowledge, knowledge content with validity in the current scenario can be filtered out, thereby avoiding outdated information from interfering with task logic. By decomposing tasks based on core intentions and key entities and building dependencies, complex business requirements can be transformed into a structured and executable sub-task system, thereby enhancing the clarity of task orchestration hierarchy and the rationality of execution order. By matching target intelligent agents from the capability library and generating intelligent agent collaboration processes, efficient adaptation and collaborative execution of tasks and executors can be achieved, thereby improving task implementation efficiency. By performing file conversion operations and presenting the process in a standardized form to a visual interface, it is possible to enhance users' understanding and confirmation of the process, thereby improving the transparency and controllability of the system.

[0061] The above-mentioned objective three of this application is achieved through the following technical solution:

[0062] A computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the above-described agent-based no-code task orchestration method.

[0063] The fourth objective of this application is achieved through the following technical solution:

[0064] A computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the above-described intelligent agent no-code task orchestration method.

[0065] In summary, this application includes the following beneficial technical effects:

[0066] 1. By receiving natural language commands from user input and acquiring relevant dynamic knowledge, the system can flexibly express user business intentions and comprehensively acquire contextual information, thereby improving the intelligent understanding capability of task orchestration. By performing timeliness verification on dynamic knowledge, it can filter out knowledge content that is valid in the current scenario, thus avoiding outdated information from interfering with task logic. By decomposing tasks based on core intentions and key entities and building dependencies, it can transform complex business requirements into a structured and executable sub-task system, thereby enhancing the clarity of task orchestration hierarchy and the rationality of execution order. By matching target intelligent agents from the capability library and generating intelligent agent collaboration processes, it can achieve efficient adaptation and collaborative execution of tasks and executors, thereby improving task implementation efficiency. By performing file conversion operations and presenting the process in a standardized form to a visual interface, it can enhance users' understanding and confirmation of the process, thereby improving the transparency and controllability of the system.

[0067] 2. By evaluating and scoring collaboration when multiple feasible agent combinations exist, the execution effect can be comprehensively judged from multiple dimensions, thereby achieving optimal solution selection; by obtaining the collaboration compatibility characteristics of target agents in the optimal combination, the coordination of interfaces, resources, and constraints among agents can be analyzed, thereby identifying potential conflict risks in advance; by using a Bayesian logistic regression model for conflict pre-identification, the compatibility of collaboration combinations can be intelligently judged using statistical inference methods, thereby reducing the collaboration failure rate; by performing adjustments when conflicts are identified and directly outputting results when no conflicts are identified, the dynamic optimization and stable output of agent orchestration processes can be achieved, thereby ensuring the robustness of the final task process;

[0068] 3. By constructing an initial intelligent agent collaborative process based on subtask dependencies and intelligent agent matching results, the contextual consistency of process logic and the integrity of execution paths can be guaranteed, thereby improving the executability of task flows; by acquiring business consensus logic rules and performing process consistency verification, it can be ensured that the generated intelligent agent process conforms to industry standards and enterprise specifications, thereby improving the standardization of process implementation; through automatic identification of logical conflicts and adjustment of process optimization strategies, self-repair of orchestration logic can be achieved, thereby reducing the number of user interventions; by generating optimization suggestions when repair is not possible and having them confirmed by the user, the transparency of interaction between the system and the user can be enhanced, thereby ensuring the flexibility and credibility of business execution.

[0069] It should be understood that the description in the Summary Section is not intended to limit the key or essential features of the embodiments of this application, nor is it intended to restrict the scope of this application. Other features of this application will become readily apparent from the following description. Attached Figure Description

[0070] The above and other features, advantages, and aspects of the embodiments of this application will become more apparent from the accompanying drawings and the following detailed description. In the drawings, the same or similar reference numerals denote the same or similar elements, wherein:

[0071] Figure 1 This is a flowchart of a no-code task orchestration method for an intelligent agent according to one embodiment of this application;

[0072] Figure 2 This is a principle block diagram of an agent no-code task orchestration system according to one embodiment of this application;

[0073] Figure 3 This is a schematic diagram of a device according to one embodiment of this application. Detailed Implementation

[0074] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0075] Furthermore, the term "and / or" in this article is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, or B existing alone. Additionally, the character " / " in this article generally indicates that the preceding and following related objects have an "or" relationship.

[0076] The present application will be further described in detail below with reference to the accompanying drawings.

[0077] In one embodiment, such as Figure 1 As shown, this application discloses a no-code task orchestration method for intelligent agents, which specifically includes the following steps:

[0078] S10: Receive natural language instructions input by the user, obtain dynamic knowledge related to the semantics of the natural language instructions, perform timeliness verification on the dynamic knowledge, and generate an instruction-knowledge association set.

[0079] Specifically, the system receives natural language task instructions from users in real time through a front-end visual interactive interface, such as "Please find products with insufficient inventory in the past 30 days and initiate a replenishment process." It identifies the user's current business environment tags, such as "inventory management" and "warehouse scheduling," and extracts candidate knowledge items from the accessed data sources, including real-time inventory data, warehouse transfer records, and historical replenishment strategy rules. A semantic vector model is used to filter knowledge highly relevant to the instruction's semantics, and timestamp extraction and scenario association analysis are performed on each candidate knowledge item. For example, it determines whether the knowledge "the inventory of a certain product is 5" is still valid, and whether its timeliness window has expired based on the product type and warehouse update frequency. The retained valid knowledge is semantically associated with the user's original instruction and stored in a structured dataset for use by the subsequent task recognition module.

[0080] S20: Perform semantic parsing on the instruction-knowledge association set, extract the core intent and key entities, perform task decomposition operations based on the core intent and key entities, generate a set of subtasks, and establish the dependency relationships between the subtasks in the set of subtasks.

[0081] Specifically, the generated instruction-knowledge set is subjected to syntactic analysis and intent classification tasks to identify the user's core intent to "trigger replenishment." Key parameter entities such as "product number," "inventory threshold," and "replenishment channel" are extracted. The task template library is then used to break down the business requirement into multiple executable sub-tasks, such as "get current inventory data," "determine if it is below the replenishment threshold," "generate a replenishment request," and "push the request to the purchasing system." Each sub-task has input and output parameter definitions and execution constraints. Furthermore, a task dependency graph is generated through data flow dependencies and logical order. For example, "generating a replenishment order" can only be executed after "inventory is below the threshold" is established. Sequential edges are constructed, and parallel execution process nodes such as "query inventory A" and "query inventory B" are identified.

[0082] S30: Based on the set of subtasks, match the target agent from the pre-built agent capability library to obtain the agent matching result.

[0083] Specifically, for each subtask, its execution capability requirements are extracted, including execution objectives such as data query, judgment, and writing; input and output formats such as JSON structure and database fields; and processing constraints such as resource limits and interface compatibility. These contents are mapped to standardized capability requirement tags, such as "inventory query [supports SKU parameters, outputs current quantity]". Registered capability tags are retrieved from the agent capability library and a matching score is calculated. The most suitable agent is selected from multiple candidates. For example, the "inventory query task" can be handled by agent A or agent B, but A only supports single SKU, while B supports batch queries and has a faster response. Therefore, agent B is prioritized as the target agent. Finally, a mapping table between subtasks and agents is output to form a complete matching structure, which can support multiple agents to collaborate on a task. For example, a "replenishment order generation" task can be completed jointly by a rule-determining agent and a report-generating agent.

[0084] S40: Generate the agent collaboration process based on the dependencies between subtasks and the agent matching results.

[0085] Specifically, the target agent matched by = is mapped onto the subtask dependency graph constructed by =, generating a collaborative flowchart with "task-agent" binding nodes as the core. The dependency type of each edge in the graph is analyzed to determine the data flow and triggering order between agents. For example, after the "inventory judgment" agent completes, its output "insufficient inventory" judgment result is passed to the "replenishment generation" agent as an input trigger condition. At the same time, data channels between agents are configured, such as API calls, message queues, and variable passing, and execution strategies are attached, such as failure rollback strategies and concurrency control flags. If resource conflicts are found between concurrent tasks, such as writing to the same interface at the same time, the process adjustment module is called to fine-tune the process structure. The problem is solved by rearranging the task order or switching compatible agents, thereby obtaining a stable and executable agent collaborative process structure.

[0086] S50: Performs a file conversion operation on the agent collaborative process to obtain a standardized process description file, outputs the standardized process description file to the visual interface for user confirmation, and triggers the agent to execute the process after user confirmation.

[0087] Specifically, the constructed agent collaboration process is converted into a standardized description language, such as BPMN, YAML, or internal DSL format. During the conversion process, the metadata structure of each node, such as agent call information, execution order, input and output parameter definitions, control strategies, and rollback mechanisms, is preserved. At the same time, redundant information is compressed to generate a concise and easy-to-read process file. This file is then submitted to the front-end visual process interface, which displays the node flow path in the form of a flowchart, such as "query inventory → determine whether to replenish stock → generate order → push order". Users can view and modify the configuration parameters and process path of each agent through the interface. After confirming that everything is correct, clicking the "execute" button will trigger the process execution engine to parse the standard file and schedule each agent to complete the entire orchestration process step by step, realizing the automatic execution of complex task chains without programming intervention.

[0088] In one embodiment, step S10 involves receiving a natural language instruction input by the user, acquiring dynamic knowledge related to the semantics of the natural language instruction, performing a timeliness verification operation on the dynamic knowledge, and generating an instruction-knowledge association set. Specifically, this includes:

[0089] S11: Receives natural language commands input by users through a visual interactive interface. Natural language commands are business expressions without format restrictions.

[0090] Specifically, the system loads a visual input component and activates a natural language input channel. It listens for business descriptions in any language form submitted by the user in the text input box, including but not limited to imperative expressions, declarative expressions, or interrogative expressions with fuzzy logic. The system automatically captures text information using an input event triggering mechanism and passes it to the preprocessing module for basic word segmentation and language normalization. Without restricting the format, the system preserves the user's original expression and language context. For example, it supports equivalent understanding inputs such as "Please help me generate a comparison chart of last week's sales data" and "Check the sales trend of the past 7 days". After completing the semantic perception preprocessing of the original natural language command, it is passed to the subsequent scene perception and semantic filtering module for association processing.

[0091] S12: Obtain all dynamic information in the current scene, and based on the preset semantic matching algorithm, filter out knowledge content related to the semantics of natural language instructions from all dynamic information in the current scene, as dynamic knowledge related to the semantics of natural language instructions.

[0092] Specifically, after the user inputs a command, the system first synchronizes the environmental tags and dynamic information set of the current business scenario from the local cache, real-time database, and external interfaces. This includes information sets from multiple dimensions such as user identity, business module context, time nodes, historical operation records, and sensor data. This information is then uniformly abstracted into a standardized knowledge item structure, forming a complete set of currently accessible knowledge content. Subsequently, based on the loaded semantic vector matching algorithm, the natural language command is vector-encoded and vector similarity is calculated with each piece of knowledge content. The commands are then filtered from high to low semantic similarity. For example, after the user inputs the command "statistics yesterday's shipment volume", knowledge items such as "goods shipment records on March 12, 2026", "daily shipment details for the past 3 days", and "distribution map of total shipment volume for each SKU" are matched as relevant content. Dynamic information that is strongly related to the user's semantic needs is retained as the input set for subsequent processing.

[0093] S13: Perform timeliness verification on dynamic knowledge based on preset knowledge time survival tag rules, and generate instruction-knowledge association set.

[0094] Specifically, the generation time or update timestamp of each selected dynamic knowledge item is read, and combined with metadata characteristics such as the type of knowledge item, the business module to which it belongs, and the update frequency, it is determined whether it is within the validity period. Specifically, the corresponding dynamic validity period threshold is determined by finding the "knowledge time survival tag rule" that matches the current task scenario. For example, the rule stipulates that inventory information is valid within 5 minutes, and employee leave records are valid for 24 hours. After obtaining the current system time, the time difference is calculated with the timestamp of each knowledge item and compared with the threshold. Only dynamic knowledge content that has not expired is retained as valid items. A mapping relationship is established with the original natural language instructions and a structured "instruction-knowledge association set" is generated for subsequent intent parsing and task decomposition processing. For example, a knowledge item "the current inventory of product A is 8" was updated 3 minutes ago. It is still considered valid within the 5-minute validity period of inventory knowledge, so it is included in the set and a semantic mapping relationship is established with the instruction "check if the inventory is lower than 10".

[0095] In one embodiment, step S13, which involves performing a timeliness verification operation on dynamic knowledge based on preset knowledge time survival tagging rules to generate an instruction-knowledge association set, specifically includes:

[0096] S131: Obtain business scenario characteristics, and based on these characteristics, generate corresponding dynamic timeliness thresholds for each piece of dynamic knowledge. Business scenario characteristics include scenario correction factors, knowledge type coefficients, business process cycles, and update frequencies.

[0097] Specifically, the system extracts business scenario feature tags from the current task context, automatically identifies the industry type, interaction mode, and operation cycle of the scenario, and reads the category, content source, and update frequency information of each dynamic knowledge in the knowledge base based on the metadata structure of each piece of dynamic knowledge. A knowledge timeliness decision function is constructed according to preset multi-factor mapping rules, and an independent dynamic timeliness threshold is calculated and generated for each piece of dynamic knowledge. The decision function uses the business process cycle as the baseline time frame, introduces scenario correction factors to adjust the evaluation weight of timeliness sensitivity, and then superimposes a knowledge type coefficient to distinguish the real-time requirements of different types of knowledge, such as inventory data, sales records, and user request logs. For example, in the order fulfillment scenario, knowledge such as "current inventory" is set to a dynamic timeliness threshold of 2 minutes, while knowledge such as "annual sales revenue" is set to a dynamic timeliness threshold of 12 hours, thereby improving the accuracy of subsequent data use and scenario matching.

[0098] Furthermore, the mathematical formula for calculating the dynamic timeliness threshold is as follows: ;

[0099] Parameter definition: : No. The dynamic timeliness threshold (in hours) for each piece of knowledge, output value;

[0100] Scene correction coefficient ( ), For scene cosine similarity;

[0101] (Model training coefficients);

[0102] Business process cycle (hours) Update frequency (times / hour), sourced from scenario configuration and logs;

[0103] Knowledge type coefficients (rule-based = 1.0, data-based = 0.7, interaction-based = 0.5) are derived from knowledge classification tags. This is to dynamically adapt to the timeliness requirements of knowledge in different scenarios and avoid knowledge erroneous obsolescence or redundancy caused by static TTL.

[0104] S132: Obtain the current time information, and calculate the difference between the timestamp of each piece of dynamic knowledge and the current time information to obtain the existing time of each piece of dynamic knowledge.

[0105] Specifically, the system synchronizes the current standard timestamp through the built-in time service interface, traverses the dynamic knowledge set obtained from the previous step of filtering, reads the original generation time or the last update time of each knowledge item, converts it to UTC format, and performs a difference operation to calculate the length of time that the knowledge has existed from its creation or update to the current time. This time difference result will be accurately represented in seconds and used as an input parameter for subsequent validity determination. For example, if a "delivery route suggestion" item was generated 2 hours ago, its existing time is 7200 seconds. This result will be used to compare and judge with the dynamic timeliness threshold of the knowledge item.

[0106] S133: Compare the existing time with the corresponding dynamic time-sensitivity threshold. If the existing time does not exceed the corresponding dynamic time-sensitivity threshold, the corresponding dynamic knowledge is determined to be valid knowledge.

[0107] Specifically, the existing time of each piece of dynamic knowledge is compared with its corresponding dynamic timeliness threshold. If the difference is within the threshold range, it is determined to be a knowledge item still within the valid time period and marked as "valid". Otherwise, it is marked as "expired" and invalid items are automatically removed in subsequent processing. For example, if the existing time of a knowledge item "warehouse shipment data in the last 5 minutes" is calculated to be 180 seconds in S132, which is lower than the set timeliness threshold of 300 seconds, then the item is retained as a valid input. Otherwise, it is discarded or a warning is issued, thereby ensuring that the content used for task orchestration and knowledge-driven processes has sufficient time sensitivity and current status.

[0108] S134: Semantically associate all valid dynamic knowledge with the corresponding natural language instructions input by the user to generate an instruction-knowledge association set.

[0109] Specifically, valid dynamic knowledge that has passed timeliness verification is used as a candidate knowledge set. Semantic mapping is performed with the user's original natural language input. A context-enhanced semantic matching algorithm is used to extract the semantic intent vector in the instruction and perform vector-level cosine similarity calculation with the semantic tags of the knowledge content. Knowledge items with a matching degree greater than a set threshold are selected to establish one-to-many or many-to-many mapping relationships. This semantic mapping structure is assembled into an "instruction-knowledge association set" in a readable and parsable standard format, which serves as the key input for subsequent intent parsing and task decomposition modules. For example, if the user input is "to calculate the total shipment volume in the past hour", the final associated dynamic knowledge may include valid content items such as "shipment record A (45 minutes ago)", "shipment record B (30 minutes ago)", and "inventory adjustment record C (15 minutes ago)", thereby ensuring that subsequent processing has both semantic accuracy and data real-time guarantee.

[0110] In one embodiment, step S20 involves semantic parsing of the instruction-knowledge association set to extract core intents and key entities, performing task decomposition operations based on the core intents and key entities to generate a set of subtasks, and establishing dependencies between the subtasks in the set. Specifically, this includes:

[0111] S21: Based on the intent recognition algorithm, extract the user's core intent from the instruction-knowledge association set.

[0112] Specifically, a semantic parsing model is loaded to perform deep intent recognition on the instruction-knowledge association set. Combining the syntactic structure of natural language instructions with the semantic background of dynamic knowledge content, keywords and expression structures representing the main task objective in the instructions are extracted as candidate intent vectors. Further, through multi-round semantic matching and contextual reasoning algorithms, the core intent label that best fits the current business context is determined. The intent label includes task type (such as statistics, query, control), target object (such as inventory, customer, delivery), and operation scope (such as time period, region). For example, when the user inputs "Please check all inbound records of Class A warehouses in the past 24 hours", the intent recognition module can parse "query" as the main intent, "inbound records" as the target object, and "past 24 hours" and "Class A warehouses" as limiting conditions, thereby forming a semantically clear core intent result for the task decomposition process.

[0113] S22: Identify key entities in the instruction-knowledge association set through entity recognition algorithms. Key entities include core entities, business parameters, and constraints.

[0114] Specifically, based on the named entity recognition model and scene dictionary, entity recognition processing is performed on semantic units in the instruction-knowledge association set. First, candidate entity fragments are extracted through part-of-speech tagging and entity boundary determination. Then, core entities with business significance (such as product number, device identifier), parameter entities (such as quantity, time period, status value), and constraint entities (such as permission restrictions, priority requirements, execution frequency) are identified by combining business dictionary rules and contextual semantic window analysis. The recognition results are labeled and encoded according to three types of structures. For example, in the input instruction "Reassign work areas to all currently active robot devices", "robot devices" can be identified as the core entity, "current" and "all active" are status parameters, and "work area" is the target parameter, thereby constructing a complete entity structure set to support subsequent task decomposition and matching steps.

[0115] S23: Based on the effective knowledge content in the core intent, key entities and instruction-knowledge association set, perform task decomposition operations to generate a set of subtasks.

[0116] Specifically, a task representation tree is constructed based on the identified core intents and key entities. The actual operation path of the execution semantic unit is determined by combining the effective knowledge content in the instruction-knowledge association set. The task generator module is used to transform the original business intent into an executable logical structure. The complex business expression containing multiple objectives, multiple conditions, or nested structures is deconstructed and split to generate a set of subtasks composed of several basic subtasks. Each subtask contains an independent operation objective, input and output fields, and execution context. For example, "to count all failed outbound orders in the past seven days and send a daily report email" can be broken down into three subtasks: to obtain outbound failed order data, to generate daily report format content, and to send email notifications. All subtasks are queued in logical order and have a unique task ID for subsequent scheduling and control.

[0117] S24: Identify the dependencies between subtasks in the subtask set and construct a task dependency graph. The dependencies include sequential dependencies, parallel dependencies, and conditional dependencies.

[0118] Specifically, based on the input and output parameters, contextual references, and logical path analysis results of each task unit in the subtask set, the dependencies between task units are automatically identified. A dependency inference model is used to identify explicit sequential dependencies, such as task B depending on the output of task A; parallel dependencies, such as task C and task D having no input-output association and can be executed simultaneously; and conditional dependencies, such as task E only being triggered when the execution result of task F meets specific conditions. A directed graph structure is constructed to describe the dependency edges and node attributes between all subtasks, forming a task dependency graph that can be used for process orchestration and execution control. For example, in the three steps of "data preparation - model training - evaluation report sending", the dependency graph will form a sequential dependency path from "data preparation" to "model training" and then to "evaluation report sending", and mark the data type transfer relationship and fault tolerance strategy, providing a clear execution blueprint for agent allocation and process control.

[0119] To enhance the adaptability of task decomposition and agent matching processes, further reduce cross-scenario configuration costs, and improve the generalization performance of models across multiple business domains, this application introduces a cross-scenario adaptation algorithm that integrates meta-learning and variational autoencoder (VAE) to address the issues of significant differences in task representation and difficulties in rule transfer across different scenarios. First, the structured configuration information of each business scenario is mapped to a 10-dimensional scenario feature vector V(S). Then, the similarity is calculated based on the following formula:

[0120]

[0121] Parameter definition: Scene feature vector (dimension=10), sourced from scene configuration; New scene parameters For reference scenario parameters (mid-platform storage). η is the learning rate. To match loss functions to subtasks and rapidly iterate sub-models for new scenarios, shortening the adaptation cycle, this scheme introduces a granularity adjustment factor G to dynamically adjust the granularity of subtask decomposition to adapt to the current agent's operating state. The mathematical formula is as follows: ;, Particle size coefficient ( ), , (Model training values); Agent load, : Proficiency (historical success rate statistics); This factor is used to dynamically balance the depth of task decomposition and execution efficiency. When the agent's state load is low and its proficiency is high, the task granularity can be appropriately refined to improve resource utilization and execution accuracy. The overall algorithm structure improves the automation level of complex task processing, enabling the task orchestration system to have the ability to quickly migrate across scenarios and perform personalized execution, fundamentally solving the pain points of "high cost of manual rule configuration and low degree of automation" in traditional solutions.

[0122] In one embodiment, step S30, namely, matching the target agent from the pre-built agent capability library based on the subtask set to obtain the agent matching result, specifically includes:

[0123] S31: Extract the task capability requirements for each subtask in the subtask set to obtain the task capability requirements for each subtask. The task capability requirements include the task target type, input and output parameter characteristics, and processing constraints.

[0124] Specifically, the capability requirement parsing operation is performed on each subtask in the subtask set, including analyzing its task target type, input and output parameter characteristics, and processing constraints. The above information is extracted in a structured manner through the rule engine to generate a standardized task capability requirement vector, which serves as the basis for subsequent intelligent agent matching. When processing the "customer order verification" task, the capability requirements of this task include attributes such as "having the ability to parse order information", "supporting structured address recognition" and "responding within 2 seconds".

[0125] S32: Based on the task capability requirement description, retrieve the corresponding candidate agents from the pre-built agent capability library.

[0126] Specifically, based on the task capability requirement vector, a set of intelligent agents with capability tags is called from a pre-built intelligent agent capability library. Each intelligent agent in the capability library is labeled with a structured capability tag, such as "order verification", "inventory query", "payment verification", etc., and its input and output data format, interface document and execution efficiency parameters are recorded. By reverse querying the capability tag index, a set of candidate intelligent agents that are consistent with or have a similarity higher than the threshold of the sub-task capability requirement description is initially selected. For example, when processing the "address standardization" sub-task, three candidate intelligent agents with the tags "address cleaning" or "geographic location recognition" are selected from the capability library.

[0127] S33: Based on the preset semantic matching algorithm and capability adaptation calculation rules, determine the target agent for each subtask from the candidate agents.

[0128] Specifically, based on the preset semantic matching algorithm and capability fit calculation rules, the candidate agents are ranked by precision. The semantic matching algorithm uses vectorized encoding and knowledge tag ontology tree to jointly evaluate similarity. The fit calculation is based on the candidate agent's execution record, input-output matching degree, interface compatibility and other dimensions to perform multi-factor weighted scoring. Finally, the optimal target agent for each subtask is selected. If the subtask is highly complex, multiple agents with complementary capabilities can be selected to construct a subtask-level collaborative unit. In the "refund review" task, if the target agent A has a semantic matching score of 0.92 and a capability fit of 0.88, it is given priority.

[0129] S34: Combine the target agents of each subtask to construct an agent collaboration combination and obtain the agent matching result.

[0130] Specifically, the identified sub-task target agents are combined according to task dependencies to construct an agent collaborative combination structure. The combination method supports multiple orchestration models such as serial, parallel, and condition-triggered. At the same time, the data flow, calling order, and callback mechanism between agents are defined in the combination structure to ensure that the task can successfully complete information interaction and dependency scheduling during the execution phase. For example, in the order processing flow, agent A is used to verify the legality of the order. If the verification is successful, agent B is triggered to query the inventory. When the inventory is sufficient, agents C and D are called concurrently to complete the logistics arrangement and customer notification, respectively, thus forming a logical closed-loop collaborative execution combination.

[0131] In one embodiment, the agent-based no-code task orchestration method further includes:

[0132] S35: When there are multiple feasible agent cooperative combinations, the agent cooperative combinations are scored based on a preset cooperative evaluation algorithm to obtain the score results.

[0133] Specifically, based on the collaborative combination of multiple intelligent agents that meet the task capability requirements, a preset collaborative evaluation algorithm is invoked to quantitatively score the core indicators of each combination's historical performance. The scoring dimensions include collaboration success rate, information transmission latency, interface compatibility, and resource utilization efficiency. Indicator weights are assigned using the entropy weight method, and the TOPSIS method is used to calculate the proximity score of each combination, forming the final score result. A higher score indicates a better collaborative effect of the combination in the current task scenario. For example, if there are three feasible combinations with scores of 0.63, 0.77, and 0.91, the combination with a score of 0.91 is prioritized for subsequent selection. The collaborative combination evaluation algorithm (TOPSIS-entropy weight method) is as follows:

[0134] The mathematical formula is:

[0135]

[0136] Parameter definition: The raw metrics (collaboration success rate, information delay, etc.) are derived from historical logs. Indicator weights For the number of combinations, (Number of indicators);

[0137] S36: Based on the scoring results, select the optimal agent collaboration group from multiple feasible agent collaboration combinations as the agent matching result.

[0138] Specifically, based on the scoring results, all candidate agent collaboration combinations are sorted, and the collaboration combination with the highest score is selected as the optimal combination. A scoring threshold is set to eliminate combinations with poor collaboration performance. If there are multiple high-scoring combinations with similar scores, the optimal solution is further selected based on the current task priority or resource utilization. For example, among the combinations with scores of 0.91, 0.89, and 0.85, since the scores of 0.91 and 0.89 are close, their average resource utilization is further evaluated, and the combination with the lower utilization is selected as the final optimal combination.

[0139] S37: Based on the optimal agent cooperative combination, obtain the cooperative compatibility characteristics of each target agent in the optimal agent cooperative combination. The cooperative compatibility characteristics include interface description information, resource requirement information and execution constraint information.

[0140] Specifically, the structured capability description information of each agent in the selected optimal agent collaboration combination is extracted, and its interface format, data interaction specifications, execution trigger conditions, dependent resource types and minimum / maximum resource consumption thresholds are obtained respectively. A combination-level collaborative compatibility feature vector is constructed as the input of the conflict prediction model. For example, in two agents A1 and A2, if A1's interface is RESTful and CPU usage is <15%, and A2's interface is GraphQL-style and GPU usage is >30%, then it is necessary to determine whether there is a conflict between their interface protocols in the combination.

[0141] S38: A Bayesian logistic regression model is used to pre-identify conflicts in collaborative compatibility features, and conflict identification results are obtained.

[0142] Specifically, the extracted collaboration compatibility feature vector is input into the Bayesian logistic regression model. Combining prior conflict probabilities and collaboration experience weights, prediction is performed, and the output is the probability value of whether the current optimal collaboration combination has an execution conflict. If this value is higher than a preset threshold (e.g., 0.8), it is considered a high-risk conflict. For example, in an order processing task, the predicted conflict probability is 0.86, and the conflict features are concentrated on inconsistent interface protocols and resource contention; therefore, the conflict handling process must be initiated. The conflict pre-identification algorithm (Bayesian logistic regression) is as follows:

[0143] Mathematical formula: ;

[0144] Parameter definition: Feature vectors (interface matching degree, format compatibility, etc.) originate from intelligent agents and middleware data; Prior conflict probability (output of consensus Bayesian network);

[0145] S39: If the conflict identification result is that a conflict has been identified, then the optimal agent cooperation combination is adjusted according to the preset conflict handling strategy.

[0146] Specifically, when a conflict is determined to exist in the collaborative combination, the corresponding conflict handling strategy is triggered according to the conflict type. If it is due to incompatible interface protocols, a replacement agent is selected for rematching. If it is due to resource contention, the execution time is rearranged or the task priority is adjusted. The default conflict handling strategy is to prioritize local replacement of agents and then globally rematch the combination to ensure that the original efficient configuration is preserved to the maximum extent. For example, after replacing the conflicting A2 with A2', the score is re-evaluated and a new combination is generated.

[0147] S310: If the conflict identification result is that no conflict is identified, the optimal agent cooperation combination will be output as the agent matching result.

[0148] Specifically, when the conflict recognition probability is lower than the set threshold and no optimization strategy is triggered, the optimal agent collaboration combination is directly output as the final agent matching result. This result is then used in the orchestration process stage. The combination is recorded in the middle platform for subsequent iteration and learning reference, and the relevant matching logs are synchronized to the data sharing middle platform to support quantization algorithm training. For example, the A1+A3 combination, which currently has no conflict and a score of 0.91, can be directly used as the matching result to participate in the orchestration process execution.

[0149] In one embodiment, step S40, which generates an agent collaboration process based on the dependencies between subtasks and the agent matching results, specifically includes:

[0150] S41: Based on the dependencies between subtasks in the subtask set and the agent matching results, construct the initial agent collaboration process.

[0151] Specifically, based on the sequential dependencies, parallel dependencies, and conditional dependencies marked in the established task dependency graph, each subtask is numbered and categorized according to the dependency chain. Combining the target agents assigned to each subtask, the calling order, execution interface, and input / output data flow of each agent are combined and configured to construct an initial collaborative process structure diagram. This structure diagram represents the interaction paths and triggering conditions between agents in the form of a directed graph. For example, in the order processing process, if subtask A (order verification) must be executed after subtask B (product inventory check) is completed, then in the collaborative process, the triggering condition of A is set to the completion flag signal output of B.

[0152] S42: Based on the current business scenario, obtain the business consensus logic rules, which include process sequence specifications, agent interaction rules, and knowledge usage paths.

[0153] Specifically, based on the business scenario tags selected by the current user, such as contract approval, project initiation, and complaint handling, the business rule platform service is invoked to retrieve the standard process templates and consensus agreements for the corresponding scenario. This includes the recommended execution order, recommended intelligent agent pairings, key knowledge reference paths, and interaction structure requirements for each type of process. The output is a structured rule table for subsequent comparison. For example, in the financial approval scenario, the consensus rule requires that the "budget approval" process be executed after the "reimbursement information verification" process, and that historical budget limit information be shared.

[0154] S43: Compare the initial intelligent agent collaboration process with the business consensus logic rules, perform logic consistency verification, and determine whether there are any execution order, data transmission methods, or knowledge call paths in the initial intelligent agent collaboration process that are inconsistent with the business specifications.

[0155] Specifically, the connection relationships and triggering conditions between each agent in the initial process structure diagram are traversed, and they are compared with the acquired consensus logic rules one by one. Semantic alignment and path parsing algorithms are used to determine whether there are cases of reversed execution order, incompatible data flow formats, or missing knowledge calls. If there are inconsistencies, inconsistency markers and position indexes are generated. For example, in the project approval process, if the "risk assessment" task is triggered before "material collection", it will be marked as an execution order conflict that does not conform to the consensus.

[0156] S44: If the verification fails, the initial agent collaboration process will be adjusted according to the preset process optimization strategy. The process optimization strategy includes reordering subtasks, replacing conflicting agents, or adjusting the information transmission logic.

[0157] Specifically, based on the identified inconsistencies, the process optimization engine is invoked to reconfigure conflicting paths. Priority is given to trying to meet business specifications by changing the task order. Secondly, other intelligent agents with higher compatibility are retrieved from the capability library to replace the current conflicting nodes. Finally, for parts of the data transmission logic that have format mismatches or semantic incompatibilities, the format standardization module is invoked to convert them, forming a new optimized process structure diagram. For example, in the "compliance review" task, since the current intelligent agent does not support OCR document parsing, it can be automatically replaced by a candidate intelligent agent A' that has this function.

[0158] S45: If automatic repair is not possible, generate optimization suggestions and prompt the user for confirmation.

[0159] Specifically, when there are multiple process conflicts that are difficult to adjust automatically using existing strategies, or when the current task structure does not support a complete replacement of the agent, the interactive optimization module is triggered to generate a structured suggestion list, which includes the conflict location, conflict type, recommended adjustment path, and a list of available agents. The key conflict areas are highlighted in the interface in the form of a visual flowchart to guide the user's decision on whether to adopt the automatic optimization suggestions or intervene manually. For example, the user can choose to keep the original agent but adjust the task order through the interface, or authorize the system to re-split the task nodes.

[0160] S46: Output the agent collaboration process that has passed logical verification or been confirmed by the user as the final agent collaboration process.

[0161] Specifically, based on the verification and optimization results, if the process logic consistency verification passes or the user confirms the conflict handling solution, the process version number is updated and marked as "confirmed status". The final collaborative process is structured into a standard process file format for subsequent process deployment and execution. At the same time, the process configuration and corresponding rule verification results are written into the version control library for auditing and traceability. For example, the intelligent agent collaborative process with the number F20240208001 can be used for this round of business execution deployment.

[0162] Furthermore, in the execution and confirmation phase of the intelligent agent collaborative process, a compliance-low-intervention algorithm is introduced to quantitatively analyze the compliance and stability of the process. A compliance score S is calculated using a fuzzy comprehensive evaluation method, where S = W∘R, the weight vector W = [0.5, 0.3, 0.2] is determined by the entropy weight method, R is a fuzzy evaluation matrix constructed based on historical statistical data, and S ranges from 0 to 1, representing the degree to which the current collaborative process meets business specifications. Further, to assess the stability of the process in subsequent execution phases, a Markov chain model is used to predict the trend of process state changes. This is achieved through iterative calculation using the state distribution vector P(t) and the state transition matrix Π trained from historical execution data. P(t+1) = P(t)·Π, thus obtaining the probability distribution of the process entering various states at the next moment; based on the compliance score S and the Markov chain prediction results, it is determined whether manual intervention is needed. When S meets the preset compliance threshold and the prediction result shows that the process is in a stable state, the manual confirmation level is automatically reduced and the intelligent agent directly executes the process. When S is lower than the threshold or the prediction shows a risk, the manual intervention level is increased and the user is prompted to confirm. For example, in approval-type business scenarios, when the algorithm evaluates the current process to have a high compliance score and the state transition probability shows that the process is stable, some manual review steps can be automatically skipped, thereby effectively reducing the frequency of manual confirmation and improving the overall execution efficiency while ensuring compliance.

[0163] Furthermore, to improve the efficiency of data value identification and utilization in the intelligent agent reasoning process, a data precision empowerment algorithm is introduced to construct a dynamic data weight optimization mechanism. This mechanism is based on four dimensions of data usage frequency, effectiveness, business value, and time decay. It constructs feature representations through a multi-head attention mechanism and generates a dynamic weight W(di) for each data point using the Softmax normalization function. This weight is used to regulate the priority of data participation in reasoning and scheduling within the collaborative process. The weight generation logic includes mapping and transforming the usage frequency, effectiveness, business value, and time decay characteristics of each data point. It also performs iterative learning based on the performance of each data point E(di) in module feedback, updating the attention parameter θAttn for continuous optimization. For example, in a retail intelligent agent scenario, for frequently invoked data with high business value and strong effectiveness but long generation time, its decay characteristics will be partially offset, ensuring it still has high weight in the current task decomposition and process generation. This achieves the strategy of prioritizing high-value data and dynamically reducing the weight of low-value data, effectively improving the accuracy and response efficiency of intelligent agent process generation. The mathematical formula is:

[0164]

[0165] Parameter definition:

[0166] : No. Dynamic weights of data items ( ), output value;

[0167] Normalization coefficient ( The source is the variance statistics of four types of features;

[0168] Multi-head attention function ( ), , , For model training parameters, ;

[0169] Frequency of use characteristics ( (Source: Historical Logs)

[0170] : Validity characteristics ( The source is the user's correction record;

[0171] Business value characteristics (core scenarios = 1.0, regular = 0.7, edge = 0.3), sourced from scenario priority configuration;

[0172] Time decay characteristics ( ), For the number of days generated, (Model training values);

[0173] Attention parameters (Learning rate) For data usage effectiveness (module feedback). This represents the total amount of data.

[0174] Furthermore, to enhance the end-to-end adaptive and continuous optimization capabilities of the agent during task orchestration, an end-to-end self-evolutionary algorithm is introduced. A collaborative model training framework based on federated learning is constructed. By introducing local model parameter update logic into each task module, model-linked optimization without centralized data transmission is achieved. Each module performs gradient descent of the loss function based on its local feedback data, updating its local parameters θi according to the following update rules: Where η is the learning rate and θglobal is the current global parameter, after all modules have been trained locally, a weighted aggregation strategy is used to fuse the parameters of all modules to obtain the new global model parameters. Where K is the total number of participating modules, ni is the number of local samples in the i-th module, and N is the total number of samples in all modules. In this way, cross-module model capability sharing and updating can be achieved while ensuring that the data does not leave the domain. For example, federated training collaboration can be formed between the user input intent recognition module, the knowledge timeliness judgment module, and the task decomposition module. Based on their respective historical feedback, the generalization performance and adaptability of the model can be dynamically improved, thereby realizing closed-loop self-evolution in the task orchestration link and significantly reducing the frequency of manual intervention and iteration costs.

[0175] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0176] In one embodiment, an agent-based no-code task orchestration system is provided, which corresponds one-to-one with the agent-based no-code task orchestration method described in the above embodiments. For example... Figure 2 As shown, this agent-based no-code task orchestration system includes a knowledge association module, a task decomposition module, an agent matching module, a process construction module, and a process conversion module. Detailed descriptions of each functional module are as follows:

[0177] The knowledge association module is used to receive natural language commands input by users, obtain dynamic knowledge related to the semantics of the natural language commands, perform timeliness verification operations on the dynamic knowledge, and generate command-knowledge association sets.

[0178] The task decomposition module is used to perform semantic parsing on the instruction-knowledge association set, extract the core intent and key entities, perform task decomposition operations based on the core intent and key entities, generate a set of subtasks, and establish the dependency relationship between each subtask in the set of subtasks.

[0179] The agent matching module is used to match target agents from a pre-built agent capability library based on a set of subtasks, and obtain agent matching results;

[0180] The process construction module is used to generate intelligent agent collaboration processes based on the dependencies between subtasks and the matching results of intelligent agents.

[0181] The process conversion module is used to perform file conversion operations on the collaborative process of intelligent agents to obtain a standardized process description file. The standardized process description file is then output to a visual interface for user confirmation, and the intelligent agent is triggered to execute the process after user confirmation.

[0182] Optional, the knowledge association module includes:

[0183] The instruction receiving submodule is used to receive natural language instructions input by the user through a visual interactive interface. Natural language instructions are business expressions without format restrictions.

[0184] The dynamic knowledge extraction submodule is used to obtain all dynamic information in the current scene. Based on the preset semantic matching algorithm, it filters knowledge content related to the semantics of natural language instructions from all dynamic information in the current scene as dynamic knowledge related to the semantics of natural language instructions.

[0185] The knowledge timeliness verification submodule is used to perform timeliness verification operations on dynamic knowledge based on preset knowledge time survival tag rules, and generate instruction-knowledge association sets.

[0186] Optionally, the knowledge timeliness verification submodule includes:

[0187] The scenario feature extraction unit is used to obtain business scenario features. Based on the business scenario features, a corresponding dynamic timeliness threshold is generated for each piece of dynamic knowledge. The business scenario features include scenario correction factor, knowledge type coefficient, business process cycle and update frequency.

[0188] The knowledge duration calculation unit is used to obtain the current time information and calculate the difference between the timestamp of each piece of dynamic knowledge and the current time information to obtain the existing time of each piece of dynamic knowledge.

[0189] The validity judgment unit is used to compare the existing time with the corresponding dynamic time-limited threshold. If the existing time does not exceed the corresponding dynamic time-limited threshold, the corresponding dynamic knowledge is judged as valid knowledge.

[0190] The semantic association unit is used to semantically associate all dynamic knowledge that is determined to be valid with the corresponding natural language instructions input by the user, and generate an instruction-knowledge association set.

[0191] Optionally, the task breakdown module includes:

[0192] The intent extraction submodule is used to extract the user's core intent from the instruction-knowledge association set based on the intent recognition algorithm;

[0193] The entity recognition submodule is used to identify key entities in the instruction-knowledge association set through entity recognition algorithms. Key entities include core entities, business parameters, and constraints.

[0194] The task decomposition submodule is used to perform task decomposition operations based on the core intent, key entities and effective knowledge content in the instruction-knowledge association set, and generate a set of subtasks.

[0195] The dependency graphing submodule is used to identify the dependencies between subtasks in the subtask set and construct a task dependency graph. The dependencies include sequential dependencies, parallel dependencies, and conditional dependencies.

[0196] Optionally, the agent matching module includes:

[0197] The capability requirement extraction submodule is used to extract the task capability requirements for each subtask in the subtask set, and obtain the task capability requirements for each subtask. The task capability requirements include the task target type, input and output parameter characteristics and processing constraints.

[0198] The candidate agent retrieval submodule is used to retrieve corresponding candidate agents from a pre-built agent capability library based on the task capability requirement description.

[0199] The agent matching submodule is used to determine the target agent for each subtask from the candidate agents based on the preset semantic matching algorithm and capability adaptation calculation rules.

[0200] The collaborative combination generation submodule is used to combine the target agents of each subtask to construct an agent collaborative combination and obtain the agent matching result.

[0201] Optionally, this agent-based no-code task orchestration system also includes:

[0202] The collaborative combination scoring submodule is used to score the collaborative combination of agents based on a preset collaborative evaluation algorithm when there are multiple feasible collaborative combinations, and obtain the scoring result.

[0203] The optimal combination selection submodule is used to select the optimal agent collaboration group from multiple feasible agent collaboration combinations based on the scoring results, as the agent matching result.

[0204] The collaborative feature extraction submodule is used to obtain the collaborative compatibility features of each target agent in the optimal agent collaborative combination based on the optimal agent collaborative combination. The collaborative compatibility features include interface description information, resource requirement information and execution constraint information.

[0205] The conflict pre-identification submodule is used to pre-identify conflicts in collaboration and compatibility features using a Bayesian logistic regression model to obtain conflict identification results.

[0206] The conflict handling submodule is used to adjust the optimal agent collaboration combination according to the preset conflict handling strategy if the conflict identification result is that a conflict has been identified.

[0207] The matching result confirmation submodule is used to output the optimal agent cooperation combination as the agent matching result if the conflict identification result is no conflict identified.

[0208] Optionally, the process building modules include:

[0209] The initial process construction submodule is used to construct the initial intelligent agent collaboration process based on the dependencies between subtasks in the subtask set and the intelligent agent matching results.

[0210] The consensus logic extraction submodule is used to obtain business consensus logic rules based on the current business scenario. The business consensus logic rules include process sequence specifications, intelligent agent interaction rules, and knowledge usage paths.

[0211] The process consistency verification submodule is used to compare the initial intelligent agent collaboration process with the business consensus logic rules, perform logic consistency verification, and determine whether there are any execution order, data transmission methods, or knowledge call paths in the initial intelligent agent collaboration process that are inconsistent with the business specifications.

[0212] The process optimization and adjustment submodule is used to adjust the initial intelligent agent collaboration process according to the preset process optimization strategy if the verification fails. The process optimization strategy includes reordering subtasks, replacing conflicting intelligent agents, or adjusting the information transmission logic.

[0213] The optimization confirmation submodule is used to generate optimization suggestions and prompt the user for confirmation if automatic repair is not possible.

[0214] The process output submodule is used to output the intelligent agent collaborative process as the final intelligent agent collaborative process after it has passed logical verification or been confirmed by the user.

[0215] Specific limitations regarding the no-code task orchestration system for intelligent agents can be found in the limitations of the no-code task orchestration method for intelligent agents described above, and will not be repeated here. Each module in the aforementioned no-code task orchestration system for intelligent agents can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device in hardware form, or stored in the memory of a computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0216] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 3As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The network interface is used for communication with external terminals via a network connection. When the computer program is executed by the processor, it implements an agent-based no-code task orchestration method.

[0217] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps:

[0218] It receives natural language commands input by the user, acquires dynamic knowledge related to the semantics of the natural language commands, performs timeliness verification on the dynamic knowledge, and generates a command-knowledge association set.

[0219] Semantic parsing is performed on the instruction-knowledge association set to extract the core intent and key entities. Based on the core intent and key entities, task decomposition operations are performed to generate a set of subtasks and establish the dependency relationships between the subtasks in the set.

[0220] Based on the set of subtasks, target agents are matched from a pre-built agent capability library to obtain agent matching results;

[0221] Based on the dependencies between subtasks and the matching results of agents, an agent collaboration process is generated.

[0222] Perform a file conversion operation on the intelligent agent collaborative process to obtain a standardized process description file. Output the standardized process description file to the visual interface for user confirmation, and trigger the intelligent agent to execute the process after user confirmation.

[0223] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, the computer program performing the following steps when executed by a processor:

[0224] It receives natural language commands input by the user, acquires dynamic knowledge related to the semantics of the natural language commands, performs timeliness verification on the dynamic knowledge, and generates a command-knowledge association set.

[0225] Semantic parsing is performed on the instruction-knowledge association set to extract the core intent and key entities. Based on the core intent and key entities, task decomposition operations are performed to generate a set of subtasks and establish the dependency relationships between the subtasks in the set.

[0226] Based on the set of subtasks, target agents are matched from a pre-built agent capability library to obtain agent matching results;

[0227] Based on the dependencies between subtasks and the matching results of agents, an agent collaboration process is generated.

[0228] Perform a file conversion operation on the intelligent agent collaborative process to obtain a standardized process description file. Output the standardized process description file to the visual interface for user confirmation, and trigger the intelligent agent to execute the process after user confirmation.

[0229] Furthermore, the hardware of this intelligent agent no-code task orchestration system is divided into two main levels: dual-core hardware and three-dimensional support hardware. The components, functions, and core technical parameters of each level are as follows:

[0230] Dual-core hardware: (1) Full-link algorithm data sharing middleware server cluster: Its function is to support the dynamic knowledge storage of the core solution, the management of the "instruction-new knowledge" association set, and the storage of consensus rules, providing accurate data input for the basic process; at the same time, it carries the dynamic weight calculation and model parameter storage of the quantization algorithm. The core technical parameters are ≥10 distributed storage nodes, equipped with 8 dynamic weight calculation acceleration cards, ≥512GB of memory, and ≥10TB of storage capacity. (2) Cross-module intelligent scheduling central hardware node: Its function is to support the linkage scheduling of each link of the core solution, coordinate the resource occupation of modules such as instruction parsing, task decomposition, and intelligent agent matching, and ensure low latency of the automated execution of the basic process; at the same time, it provides computing power allocation for the quantization algorithm. The core technical parameters are equipped with 4 task priority scheduling chips, 2 linkage prediction dedicated units, 6 GPU tensor calculation units, and latency ≤5ms.

[0231] Three-dimensional support hardware: (1) Business data acquisition and processing layer: The function is to support the dynamic knowledge capture and instruction reception of the core solution, collect business dynamic information and consensus change data, and transmit them to the middle platform after preprocessing to ensure the data integrity of the knowledge association and consensus verification links of the basic process. The core technical parameters are equipped with 20 business scenario data acquisition terminals, 8 consensus change capture interface hardware, 15 intelligent agent status real-time monitoring hardware, and a transmission bandwidth ≥10Gbps. (2) Intelligent computing layer: The function is to provide computing power support for the consensus verification and conflict adjustment of the core solution, quickly complete the logical conflict judgment and process optimization; at the same time, it carries the conflict pre-identification and process pre-performance calculation of the quantization algorithm. The core technical parameters are equipped with 12 dedicated computing hardware for collaborative conflict pre-identification, a digital twin pre-performance environment GPU cluster containing 32 GPUs, and 8 dedicated Bayesian inference chips. (3) Interaction and execution layer: The function is to support the visual interaction (instruction input, process viewing and confirmation) and execution triggering of the core solution, realize the closed loop of "user input → process orchestration → intelligent agent execution"; at the same time, it feeds back execution data for algorithm iteration. The core technical parameters are: equipped with a visual interactive interface server ×4, an intelligent agent capability library server ×6, and an underlying communication and scheduling module ×10, with a response time ≤10ms.

[0232] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments described above. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0233] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the system can be divided into different functional units or modules to complete all or part of the functions described above.

[0234] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.

Claims

1. A no-code task orchestration method for intelligent agents, characterized in that, The aforementioned no-code task orchestration method for intelligent agents includes: Receive natural language instructions input by the user, acquire dynamic knowledge related to the semantics of the natural language instructions, perform timeliness verification on the dynamic knowledge, and generate an instruction-knowledge association set; Semantic parsing is performed on the instruction-knowledge association set to extract the core intent and key entities. Based on the core intent and key entities, task decomposition operations are performed to generate a set of subtasks and establish the dependency relationships between the subtasks in the set of subtasks. Based on the set of subtasks, target agents are matched from the pre-built agent capability library to obtain agent matching results; Based on the dependencies between the subtasks and the matching results of the agent, an agent collaboration process is generated. A file conversion operation is performed on the intelligent agent collaborative process to obtain a standardized process description file. The standardized process description file is then output to a visual interface for user confirmation, and the intelligent agent execution process is triggered after user confirmation.

2. The agent-based no-code task orchestration method according to claim 1, characterized in that, The process of receiving natural language commands input by the user, acquiring dynamic knowledge related to the semantics of the natural language commands, performing timeliness verification on the dynamic knowledge, and generating a command-knowledge association set specifically includes: The system receives natural language commands input by the user through a visual interactive interface. These natural language commands are business expressions without format restrictions. All dynamic information in the current scene is obtained, and based on a preset semantic matching algorithm, knowledge content related to the semantics of the natural language instruction is filtered from all dynamic information in the current scene as dynamic knowledge related to the semantics of the natural language instruction. Based on preset knowledge time survival tag rules, the timeliness verification operation is performed on the dynamic knowledge to generate the instruction-knowledge association set.

3. The agent-based no-code task orchestration method according to claim 2, characterized in that, The timeliness verification operation performed on the dynamic knowledge based on the preset knowledge time survival tagging rules, generating the instruction-knowledge association set, specifically includes: Obtain business scenario characteristics, and based on the business scenario characteristics, generate a corresponding dynamic timeliness threshold for each piece of dynamic knowledge. The business scenario characteristics include scenario correction factor, knowledge type coefficient, business process cycle and update frequency. Obtain the current time information, and calculate the difference between the timestamp of each piece of dynamic knowledge and the current time information to obtain the existing time of each piece of dynamic knowledge; The existing time is compared with the corresponding dynamic time-sensitivity threshold. If the existing time does not exceed the corresponding dynamic time-sensitivity threshold, the corresponding dynamic knowledge is determined to be valid knowledge. All valid dynamic knowledge is semantically associated with the corresponding natural language instructions input by the user to generate the instruction-knowledge association set.

4. The agent-based no-code task orchestration method according to claim 1, characterized in that, The process of semantically parsing the instruction-knowledge association set to extract core intents and key entities, performing task decomposition based on the core intents and key entities to generate a set of subtasks, and establishing dependencies between the subtasks in the set specifically includes: Based on the intent recognition algorithm, the user's core intent is extracted from the instruction-knowledge association set; The key entities in the instruction-knowledge association set are identified by an entity recognition algorithm. The key entities include core entities, business parameters, and constraints. Based on the core intent, the key entities, and the valid knowledge content in the instruction-knowledge association set, a task decomposition operation is performed to generate the sub-task set; Identify the dependencies between subtasks in the set of subtasks and construct a task dependency graph. The dependencies include sequential dependencies, parallel dependencies, and conditional dependencies.

5. The no-code task orchestration method for intelligent agents according to claim 1, characterized in that, The step of matching target agents from a pre-built agent capability library based on the sub-task set to obtain agent matching results specifically includes: For each subtask in the set of subtasks, the task capability requirements are extracted to obtain the task capability requirements of each subtask. The task capability requirements include the task target type, input and output parameter characteristics and processing constraints. Based on the task capability requirement description, the corresponding candidate agents are retrieved from the pre-built agent capability library; Based on the preset semantic matching algorithm and capability adaptation calculation rules, the target intelligent agent for each sub-task is determined from the candidate intelligent agents; The target agents of each subtask are combined to construct an agent collaboration combination, and the agent matching result is obtained.

6. The no-code task orchestration method for intelligent agents according to claim 5, characterized in that, The agent-based no-code task orchestration method further includes: When there are multiple feasible agent collaboration combinations, the agent collaboration combinations are scored based on a preset collaboration evaluation algorithm to obtain a score result; Based on the scoring results, the optimal agent collaboration group is selected from the multiple feasible agent collaboration combinations as the agent matching result. Based on the optimal agent cooperation combination, the cooperation compatibility characteristics of each target agent in the optimal agent cooperation combination are obtained. The cooperation compatibility characteristics include interface description information, resource requirement information and execution constraint information. A Bayesian logistic regression model was used to pre-identify conflicts in the cooperative compatibility features, and the conflict identification results were obtained. If the conflict identification result indicates that a conflict has been identified, the optimal agent cooperation combination will be adjusted according to the preset conflict handling strategy. If the conflict identification result is that no conflict is identified, then the optimal agent cooperation combination is output as the agent matching result.

7. The no-code task orchestration method for intelligent agents according to claim 1, characterized in that, The process of generating an agent collaboration flow based on the dependency relationships between the subtasks and the matching results of the agent specifically includes: Based on the dependencies between subtasks in the subtask set and the agent matching results, an initial agent collaboration process is constructed. Based on the current business scenario, obtain business consensus logic rules, which include process sequence specifications, intelligent agent interaction rules, and knowledge usage paths; The initial intelligent agent collaboration process is compared with the business consensus logic rules, and a logic consistency check is performed to determine whether there is an execution order, data transmission method or knowledge call path in the initial intelligent agent collaboration process that is inconsistent with the business specifications. If the verification fails, the initial intelligent agent collaboration process is adjusted according to the preset process optimization strategy. The process optimization strategy includes reordering subtasks, replacing conflicting intelligent agents, or adjusting the information transmission logic. If automatic repair is not possible, optimization suggestions will be generated and the user will be prompted for confirmation. The intelligent agent collaboration process that has passed logical verification or been confirmed by the user will be output as the final intelligent agent collaboration process.

8. A no-code task orchestration system for intelligent agents, characterized in that, The intelligent agent no-code task orchestration system includes: The knowledge association module is used to receive natural language instructions input by the user, obtain dynamic knowledge related to the semantics of the natural language instructions, perform timeliness verification on the dynamic knowledge, and generate an instruction-knowledge association set. The task decomposition module is used to perform semantic parsing on the instruction-knowledge association set, extract the core intent and key entities, perform task decomposition operations based on the core intent and key entities, generate a set of subtasks, and establish the dependency relationship between each subtask in the set of subtasks. The agent matching module is used to match target agents from a pre-built agent capability library based on the subtask set, and obtain agent matching results; The process construction module is used to generate an intelligent agent collaborative process based on the dependency relationship between the sub-tasks and the matching result of the intelligent agent; The process conversion module is used to perform file conversion operations on the intelligent agent collaborative process to obtain a standardized process description file, output the standardized process description file to the visual interface for user confirmation, and trigger the intelligent agent to execute the process after user confirmation.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the agent no-code task orchestration method as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of the agent no-code task orchestration method as described in any one of claims 1 to 7.

Images