An agent-based no-code orchestration method

Abstract

This application provides a no-code orchestration method based on intelligent agents, belonging to the fields of artificial intelligence and process automation. It addresses the problems of high barriers to entry, rigid processes, and ineffective utilization of dynamic knowledge in related technologies. This method dynamically constructs group collaboration containers to accommodate intelligent agents in response to no-code operations; parses task intents and generates collaborative task sequences in response to natural language instructions; converts graphically configured interaction rules into underlying protocols to drive collaborative operations; and captures and utilizes intermediate information as dynamic context in real time throughout the process. This enables users to intuitively and flexibly organize and drive multi-agent collaboration, achieving real-time knowledge fusion and utilization, significantly reducing the barrier to entry and improving the flexibility and intelligence level of collaboration.

Description

Technical Field

[0001] This application relates to the fields of artificial intelligence and process automation, and in particular to an agent-based no-code orchestration method. Background Technology

[0002] With the rapid development of artificial intelligence technology, AI agents, as software entities with autonomous perception, decision-making, and execution capabilities, have been applied to many complex task scenarios. How to effectively organize and schedule multiple AI agents to work collaboratively has become key to improving task processing capabilities and the level of intelligence.

[0003] Existing technical solutions mainly fall into several categories: First, no-code / low-code business process management (BPM) platforms, which allow users to orchestrate deterministic workflows by dragging and dropping pre-built functional modules (such as database operations and email sending); second, multi-agent systems (MAS), which enable fixed collaboration between agents through pre-programmed communication protocols (such as contract network protocols and blackboard models); and third, intelligent chatbots, which can parse user commands and call single or serial API services.

[0004] However, these existing technologies have significant drawbacks: no-code BPM platforms handle passive, deterministic functional units, making them unsuitable for agents with autonomy and uncertain output; their workflows are static and rigid, making it difficult to integrate dynamically changing information. While multi-agent systems can achieve complex collaboration, their configuration is highly dependent on specialized technical knowledge, protocols are rigid, ordinary users cannot participate in customization, and they cannot immediately utilize unstructured knowledge generated during tasks. Intelligent chatbots are essentially human-machine dialogues or simple service sequences, lacking true, autonomous, and orderly "group chat"-style collaborative capabilities among multiple agents. Therefore, there is an urgent need for a solution that allows non-technical users to intuitively and dynamically organize and drive multiple autonomous agents to collaborate, and to immediately utilize the flowing knowledge generated during the collaboration process. Summary of the Invention

[0005] This application provides a no-code orchestration method based on intelligent agents, which enables efficient collaborative work of multiple autonomous intelligent agents in an intuitive, dynamic manner that supports real-time knowledge fusion. This solves the problems of high threshold for intelligent agent collaborative configuration, rigid processes, and inability to utilize dynamic knowledge in existing technologies.

[0006] Firstly, this application provides a no-code orchestration method based on intelligent agents. In response to user configuration operations via a graphical interface or natural language, a group collaboration container is dynamically constructed or modified. This group collaboration container logically accommodates multiple intelligent agent functional modules with autonomous decision-making capabilities. In response to natural language task instructions input to the group collaboration container, the natural language task instructions are parsed through natural language processing to identify the task intent. Based on the identified task intent and the capability descriptions of each intelligent agent functional module within the group collaboration container, a collaborative task sequence is generated. This collaborative task sequence defines the tasks, execution order, and data flow to be performed by at least two intelligent agent functional modules within the group collaboration container. In response to interaction rules configured for the group collaboration container, the interaction rules are converted into underlying communication protocol instructions for scheduling message passing and triggering timing between intelligent agents. Based on the underlying communication protocol instructions and the collaborative task sequence, the intelligent agent functional modules within the group collaboration container are driven to perform collaborative operations. During the execution of the collaborative operations, intermediate process information generated within the group collaboration container is captured in real time, and this intermediate process information is added as a dynamic context to the input data of subsequent related intelligent agent functional modules.

[0007] By adopting the above technical solutions, this method provides a dynamically adjustable logical space for multi-agent collaboration through a "group collaboration container," making organizing agents as simple as "creating a group." Through natural language instruction parsing and task sequence generation, it achieves automatic and intelligent transformation from high-level intentions to complex multi-agent workflows. By converting graphical interaction rules into underlying protocols, non-technical users can define complex interaction logic between agents. Most importantly, by capturing and utilizing intermediate process information as dynamic context in real time during collaborative operations, the system can instantly integrate and utilize "fresh" knowledge generated during task execution, achieving a leap from static workflows to dynamic knowledge-based collaborative workflows. This provides a highly flexible, intelligent, and easy-to-use multi-agent collaborative orchestration solution.

[0008] Furthermore, the dynamic construction or modification of a group collaboration container includes: receiving a configuration instruction issued by a user to associate at least two of the intelligent agent functional modules as the same collaboration group to form the group collaboration container; wherein the group collaboration container is a logical entity that independently maintains the collaboration context between the intelligent agent functional modules.

[0009] By adopting the above technical solution, the container construction operation becomes intuitive and flexible, and the container has independent collaborative state management capabilities, providing a stable and isolated execution environment for subsequent collaborative operations.

[0010] Furthermore, the step of generating a collaborative task sequence based on the identified task intent and the capability descriptions of each agent functional module within the group collaboration container includes: decomposing the task intent into multiple sub-tasks; matching at least one execution agent intelligent agent functional module to each sub-task by calculating the semantic similarity between each sub-task and the natural language capability descriptions of each agent functional module; and arranging the execution order of each execution agent intelligent agent functional module according to the logical or data dependencies between the multiple sub-tasks to form the collaborative task sequence.

[0011] By adopting the above technical solutions, capability matching is performed through semantic similarity calculation, which improves the accuracy and automation level of task allocation; and orchestration based on the dependencies between tasks ensures the logical correctness and execution efficiency of the collaborative process.

[0012] Furthermore, in response to the interaction rules configured for the group collaboration container, the interaction rules are converted into underlying communication protocol instructions, including: providing rule configuration elements through a graphical interface for defining the speaking order, triggering conditions, or priority strategies among intelligent agent functional modules; and mapping the rule logic set by the user through the rule configuration elements, which describes the collaboration process, into machine-executable protocol instructions that control message queue sorting, communication token allocation, or event listening registration.

[0013] By adopting the above technical solutions, users are provided with a visual tool that intuitively defines complex collaborative strategies (such as brainstorming, review meetings, etc.), and the underlying technical details are shielded through an automatic conversion mechanism, which greatly reduces the configuration and usage threshold of multi-agent collaborative systems.

[0014] Furthermore, the rule configuration element includes a configuration block for defining conditional triggering logic; the step of mapping the rule logic set by the user through operating the rule configuration element into machine-executable protocol instructions includes: converting the state defined by the conditional clause in the conditional triggering logic into a corresponding event listening registration instruction; and converting the action defined by the execution clause in the conditional triggering logic into a message routing instruction sent to a specific intelligent agent functional module when a corresponding event is listened to.

[0015] By adopting the above technical solutions, support for complex event-responsive collaborative scenarios is achieved (such as triggering the intervention of other intelligent agents when a certain intelligent agent outputs a specific result), making the collaborative logic more flexible and intelligent.

[0016] Furthermore, the real-time capture of intermediate process information generated within the group collaboration container, and the addition of the intermediate process information as a dynamic context to the input data of subsequent related intelligent agent functional modules, includes: listening to and obtaining natural language conclusion information output by any intelligent agent functional module during collaborative operation; and inserting the natural language conclusion information into the input prompt information of a specified subsequent intelligent agent functional module.

[0017] By adopting the above technical solutions, seamless and real-time transmission and utilization of unstructured knowledge among intelligent agents are realized, enabling subsequent decisions of intelligent agents to be based on the latest and complete collaborative progress, significantly improving the coherence of collaboration and the quality of results.

[0018] Furthermore, the method also includes: performing real-time analysis on the intermediate process information generated within the group collaboration container, extracting text summaries representing consensus conclusions or key points of disagreement; outputting the text summaries, or adding the text summaries to the input data of a designated intelligent agent functional module.

[0019] By adopting the above technical solutions, the core outputs or key disputes of multi-agent collaboration can be automatically extracted. This not only makes it easier for users to quickly grasp the progress of collaboration, but also allows the summary to be fed back to the system as high-quality knowledge input, further driving or optimizing the collaboration process and improving the value density and decision support capabilities of collaboration.

[0020] Furthermore, the dynamic construction or modification of a group collaboration container also includes: automatically executing the construction or modification operation in response to detecting an automated triggering condition related to a preset purpose of the group collaboration container.

[0021] By adopting the above technical solutions, the system can intelligently respond to external events or changes in internal state, automatically organize corresponding intelligent agent collaborative groups, realize the evolution from passive orchestration to active, adaptive collaboration, and expand application scenarios.

[0022] Furthermore, the method also includes: when it is detected that there are ambiguous or missing parameters in the task intent, driving a demand clarification agent function module to interact with the user in natural language to obtain supplementary information; after updating the task intent based on the supplementary information, re-executing the disassembly, matching and orchestration steps.

[0023] By adopting the above technical solutions, the tolerance and processing capability for ambiguous instructions are enhanced. By introducing an interactive clarification process, the accuracy and effectiveness of the generated task sequences are ensured, thereby improving the practicality and robustness of the system.

[0024] Furthermore, the method also includes: attaching time-sensitive tags to specific knowledge entries associated with the collaborative task sequence, the interaction rules, or the intermediate process information; and performing at least one operation, either issuing a prompt to the user or automatically triggering an information update verification process, based on a comparison between the current time and the time-sensitive tags.

[0025] By adopting the above technical solution, a proactive management mechanism for knowledge effectiveness is introduced, which can prompt users or automatically process potentially outdated information, rules, or tasks, ensuring the long-term effectiveness of the collaborative system and the timeliness of decision-making.

[0026] In summary, this application has at least the following beneficial effects:

[0027] It provides a method that allows non-technical users to dynamically organize and drive multi-agent collaboration through intuitive operation, and can integrate and utilize dynamic knowledge in real time, thus realizing flexible, intelligent and low-threshold complex task processing.

[0028] Through semantic matching and dependency orchestration, the automatic generation of natural language instructions into precise and efficient multi-agent workflows is achieved.

[0029] By automatically converting visual collaborative rules into underlying communication protocols, the definition of complex agent interaction strategies becomes simple and feasible;

[0030] By capturing and utilizing collaborative intermediate information in real time as a dynamic context, true "knowledge preservation" and coherent collaboration are achieved.

[0031] Through consensus extraction and automated triggering mechanisms, the collaborative output value and system intelligent response capabilities have been further enhanced.

[0032] 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

[0033] 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:

[0034] Figure 1 A schematic diagram of an exemplary operating environment in which embodiments of this application can be implemented is shown.

[0035] Figure 2 A flowchart of an agent-based no-code orchestration method according to an embodiment of this application is shown. Detailed Implementation

[0036] 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.

[0037] 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.

[0038] This application provides a no-code orchestration method based on intelligent agents, which allows non-technical users to dynamically organize and drive multiple autonomous intelligent agents to perform complex collaborations through intuitive graphical or natural language operations. It can also integrate dynamic knowledge generated during task execution in real time, thereby significantly reducing the usage threshold of multi-agent systems and significantly improving the flexibility, intelligence level and decision quality of collaborative operations.

[0039] Figure 1 A schematic diagram of an exemplary operating environment in which embodiments of this application can be implemented is shown.

[0040] Reference Figure 1 The operating environment includes a complete hardware and software system for implementing the agent-based no-code orchestration method. The system employs a distributed architecture, with its software deployed on top of the corresponding hardware infrastructure and working collaboratively via a network.

[0041] At the core of this operating environment is a server cluster deployed in a data center. Multiple software service modules carrying the core logic of the described method run within the cluster. Among them, the container management service is responsible for responding to configuration operations. A configuration operation refers to a user-issued instruction to establish collaborative relationships between multiple intelligent agent functional modules. In one specific implementation, the client application provides a visual panel where the user completes the configuration by dragging and dropping icons representing different intelligent agents to a shared area. The container management service then creates a corresponding group collaboration container logical instance. In other implementations, the configuration operation can also be a natural language command from the user, such as "Please create a group containing intelligent agents A and B," or by directly clicking a preset "Project Review Expert Group" template. The container management service performs dynamic construction, modification, and lifecycle management of the group collaboration container. The group collaboration container is an entity created in system memory that logically accommodates and isolates the execution context of a group of intelligent agent functional modules; it independently maintains its member list and collaboration state.

[0042] The natural language processing module parses and identifies the task intent of the natural language task instructions input to the group collaboration container. The function of this module is to understand the user's instruction goals. In one specific embodiment, the module uses a pre-trained model based on the Transformer architecture to classify the intent and extract entities from the instructions. For example, for the instruction "summarize customer feedback from last week and analyze the main issues," the module identifies the combined intent of "text summary" and "issue analysis," and extracts the time entity "last week." In other embodiments, rule-based matching or traditional machine learning models can also be used to achieve intent understanding.

[0043] The task orchestration engine decomposes, matches, and sorts tasks based on the identified task intent and capability descriptions obtained from the agent's functional module library, ultimately generating a collaborative task sequence. Task decomposition can break down complex intents into sequential or parallel sub-tasks based on the intent and a pre-defined task graph. Capability matching focuses on associating sub-task requirements with the agent's description. In a specific example, the engine calculates the semantic similarity between the sub-task text and the natural language capability descriptions of each agent's functional modules. Semantic similarity can be calculated using methods such as cosine similarity, with a matching threshold set according to task precision requirements, for example, between 0.75 and 0.95, with 0.85 being a commonly used and effective value. Based on the matching results and the logical or data dependencies between sub-tasks, the engine orchestrates a collaborative task sequence defining the execution order and data flow. Another matching method can be precise filtering based on pre-labeled skill tags.

[0044] The rule conversion engine provides a graphical rule configuration interface and maps configured interaction rules to underlying communication protocol instructions for schedulable message passing. Interaction rules define the collaborative behavior patterns between functional modules of the agents within the container. In the provided graphical interface, users can combine various rule elements. For example, by selecting an "equal speaking" rule element, all agents can speak freely; by combining a "conditional trigger" rule element, agent B can be notified to intervene when agent A's output contains the keyword "high-risk". The rule conversion engine compiles these high-level, visual rule descriptions into specific, executable communication instructions. For example, "equal speaking" is mapped to permission to broadcast messages to all member agents; the aforementioned conditional trigger rule is mapped to registering a content filter for agent A's output on the message bus, automatically generating and sending a message to agent B's input queue when the condition is met. In other embodiments, rules can also be defined by filling out structured forms or editing simple scripts.

[0045] In addition, the system includes a dynamic context management module, which captures intermediate process information generated within the group collaboration container in real time during collaborative operations and manages and distributes it as dynamic context. Intermediate process information mainly refers to the outputs generated by the agent's functional modules during collaboration. This module captures this information by monitoring relevant message streams on the internal communication bus. In one implementation, the captured information is added immediately and as is before the input prompts for subsequent related agents. For example, when a data analysis agent outputs a conclusion, this conclusion is captured by the dynamic context management module and inserted into the system prompts for a subsequent report writing agent, enabling it to work based on the preceding conclusion. Another management approach is to lightweight structure the captured information before redistribution, for example, by extracting key data fields.

[0046] On the user side, users interact through terminal devices such as personal computers or smartphones. These devices run client applications that provide a graphical user interface for dragging, clicking, or inputting natural language commands. This interface serves as the direct interface for users to perform no-code configuration operations and issue task commands. In a typical scenario, users access this application through a web browser. The terminal device establishes a secure connection with the server cluster via the internet or corporate intranet to transmit operation commands and receive processing results.

[0047] Within the server cluster, various software service modules and instantiated agent functional modules connect and interact through a highly available internal communication bus. This bus, built on message queue or event stream technology, reliably transmits control messages and collaborative data generated according to protocol instructions, thereby driving asynchronous, ordered collaborative work among multiple agents within the group collaboration container. For example, using Kafka or RabbitMQ as the bus technology, each group collaboration container can be associated with one or more message topics. The entire runtime environment also integrates a unified security authentication and data persistence mechanism, ensuring secure system access and reliable storage of state information.

[0048] In summary, this runtime environment deploys the specific software modules of the described method on a server-side cluster, provides interactive interfaces on the user end, and organically links the various components through an internal communication bus. Together, these components form an integrated technical implementation environment that supports the entire process from agent organization, task parsing and orchestration, rule-driven processes to real-time knowledge fusion. This environment demonstrates how to achieve dynamic and intelligent collaboration among multiple agents in a no-code manner through specific service interactions, data processing, and control flow.

[0049] This application specifically discloses a complete implementation of a no-code orchestration method based on intelligent agents.

[0050] Figure 2 A flowchart of an agent-based no-code orchestration method according to an embodiment of this application is shown.

[0051] Reference Figure 2 This method relies on the operating environment described above, and through the collaborative operation of the various software service modules deployed therein, it realizes the entire process from intelligent agent organization and task parsing to collaborative execution and knowledge fusion.

[0052] This approach begins with the container management service responding to user configuration operations. The core of this step lies in responding to user no-code operations to dynamically create or adjust a logical space for agent collaboration. Users issue configuration commands through a graphical interface or natural language interface of the client application, forming the starting point for no-code interaction. For example, in a graphical interface implementation, users can intuitively form a team by dragging icons representing different agents (such as "data analyst" or "copywriter") to a canvas area called a "collaboration space." The container management service receives this command and dynamically builds a group collaboration container in the background. This container is logically generated within the system to accommodate multiple instances of agent functional modules with autonomous decision-making capabilities and operates as an independent logical entity maintaining a collaboration context. In another implementation using natural language commands, users can directly input "create a group containing agent A and agent B," and the system, after understanding the natural language, can similarly create the container. Build or modification operations can also be triggered automatically, meaning they can be completed automatically when the system detects an event related to a container's preset purpose. For example, when a monitoring system detects that the server error rate exceeds 5%, it can automatically create an emergency collaboration container containing intelligent agents for operation and maintenance diagnosis, log analysis, and contingency plan execution. Besides the above examples, configuration operations can also involve selecting a preset template, such as a "project review template," to generate a container containing the corresponding intelligent agent combination with a single click; or triggering container construction via an external system through an API call.

[0053] Subsequently, the method enters the intelligent planning phase, led by the natural language processing module and the task orchestration engine. This step aims to automatically transform the user's high-level intent into an executable multi-agent collaborative plan. When the user or system inputs a natural language task instruction into the established group collaboration container, the natural language processing module parses the instruction, identifying its core task intent and key parameters. For example, for the instruction "Summarize customer feedback from last week and analyze the main issues," the module identifies a composite intent of "text summary" and "problem analysis." Based on this intent, the task orchestration engine, combined with the natural language capability descriptions obtained from the functional modules of each agent within the container, generates a detailed sequence of collaborative tasks. The generation process specifically includes: breaking down the identified macro-level task intent into a series of specific sub-tasks; assigning appropriate execution agent functional modules to each sub-task by calculating the semantic similarity between the descriptions of each sub-task and the capability descriptions of each agent; and finally, orchestrating the working order and data interfaces of all execution agents based on the logical or data dependencies between sub-tasks, forming a collaborative task sequence that ultimately defines the tasks, order, and flow. Semantic similarity can be calculated using various algorithms, such as calculating cosine similarity after generating sentence vectors based on a pre-trained language model (e.g., BERT). The matching threshold can be adjusted according to task complexity, for example, set between 0.75 and 0.9, with 0.85 being a commonly used optimal value to ensure both accuracy and flexibility in matching. Besides semantic-based matching, other implementation methods can include precise matching based on predefined skill tags or recommended matching based on collaborative historical performance. If the task intent is ambiguous, the system can drive a dedicated clarifying agent to interact with the user to obtain supplementary information and update the plan accordingly. For example, when the instruction is "analyze sales data," the clarifying agent will ask, "Which time period and which regions' sales data should be analyzed?" and re-plan after the user provides the details.

[0054] Subsequently, the method achieves precise control over collaborative behavior through a rule transformation engine. This step allows users to define the interaction logic between agents in a no-code manner, which is then automatically converted into executable instructions by the system. Users can configure interaction rules for containers through a graphical interface provided by the client application, such as defining the speaking order or setting conditional triggering logic. The rule transformation engine maps these high-level rules, which are oriented towards business logic, into low-level protocol instructions that can be executed by the internal communication bus. For example, by dragging and dropping a "polling speak" rule element onto the canvas, the engine converts it into a series of control messages: generating a "speaking token" and sending it to each agent in the order of the agent list; only the agent holding the token can publish messages to the bus. Another typical rule is conditional triggering, such as setting "if the confidence level of an agent's output is lower than the threshold X, then forward its output to agent Y for review." Here, the threshold X can be set to a specific value, such as 0.8, with a reasonable range between 0.7 and 0.9. The rule transformation engine will create an event listener for this, and when it hears a message that meets the condition, it will automatically generate a directed routing instruction. Other examples of interaction rules include "free discussion mode" (mapped to allow all agents to speak concurrently) and "chairman mode" (mapped to allow only specific agents to be assigned speaking rights). Ultimately, based on these protocol instructions and the aforementioned collaborative task sequence, the system drives the functional modules of each agent within the container to initiate and execute asynchronous, ordered collaborative operations.

[0055] Throughout the collaborative workflow, the dynamic context management module operates continuously to ensure knowledge preservation. This step ensures that information generated during collaboration is captured and effectively utilized in real time. The module monitors and captures intermediate process information generated by each agent via the internal communication bus, particularly their output natural language conclusions. The captured information is immediately added as dynamic context to the input data of subsequent agents. Specifically, the module can monitor message topics for a specific container. When agent A publishes a conclusion, the module temporarily stores the conclusion text in the container's context cache. When it needs to drive agent B, the system extracts the relevant context from the cache and appends it before B's original instruction when constructing B's input prompt. For example, B's final prompt might become: "Previous analysis indicates that sales in East China have increased, but gross profit has decreased. Based on this, analyze potential risk points." Another implementation is to store the context in the container's shared memory area for each agent to query at runtime. Furthermore, the system can analyze this intermediate information in real time. For example, when multiple agents express their opinions on the same issue, the system can call a text summarization model to automatically generate a consensus and disagreement summary, and output it to the user interface or as new context feedback to the agents to promote consensus formation.

[0056] Furthermore, the method includes auxiliary management mechanisms. For example, time-sensitive tags can be attached to tasks, rules, or key knowledge items. By comparing the current time with the tag, the system can proactively notify users that the information is outdated or automatically trigger an update verification process. For instance, a market analysis rule can be set to have a validity period of 7 days (168 hours), or an external data source referenced in a collaborative task can be appended with its original publication timestamp. The duration of the time-sensitive tag can be set according to the type of information; for example, rapidly changing information (such as stock market dynamics) can be set to several minutes to several hours, while relatively stable information (such as company rules and regulations) can be set to several months. When the system detects that the TTL of a task has expired, or that the publication time of a piece of knowledge has exceeded a preset threshold (such as 6 months), it can pop up a reminder on the user interface or automatically start a knowledge update sub-process, driving the retrieval agent to find the latest information.

[0057] In summary, this embodiment, through the above-described sequentially connected and closely coordinated steps and their various implementation methods, fully demonstrates the specific implementation process of a collaborative orchestration method that utilizes a no-code interactive approach to dynamically organize multiple agents, intelligently parse tasks, flexibly define rules, and achieve real-time knowledge fusion. The specific examples and parameter ranges provided for each step offer clear guidance for those skilled in the art to understand and implement this invention, and also reflect the broad scope of protection covered by this invention.

[0058] Optimize technical solutions

[0059] This application further discloses a technical solution for systematically optimizing the no-code orchestration method. This solution is not independent of the foregoing, but rather introduces an endogenous high-level processing layer called a "cooperative system autonomous evolution engine" on top of the dynamic collaborative process constructed in the aforementioned method embodiments. This engine is deployed in the runtime environment as a backend service, and its core mission is to autonomously optimize the accuracy of agent capability matching, the effectiveness of interaction rules, the rationality of resource scheduling, and the innovation of collaborative strategies by securely and continuously analyzing all collaborative data streams generated during system runtime, thereby enabling the entire system to possess the ability to self-improve and adapt to complex environments. The operation of this engine is tightly coupled with the container management, task orchestration, and rule transformation modules in the aforementioned embodiments, receiving their outputs as inputs and feeding the optimization results back to these modules, forming a complete optimization closed loop.

[0060] The input data for the autonomous evolution engine of this collaborative system originates from the multimodal data streams naturally generated during the operation of the method embodiment. Specifically, it mainly includes four categories of data sources: First, the complete execution records of each agent in the agent functional module library in each collaborative task, including the inputs it receives, the natural language outputs it produces, the metadata tags attached to the task, and the final task completion evaluation. This data constitutes the original experience pool. Secondly, there are all the interaction logs generated when users configure interaction rules through a graphical interface or natural language. These include the user's initial vague description, the system-generated rule draft, the confirmation and modification dialogue between the user and the rule-clarifying agent, and the final effective rule configuration. This data constitutes the intent alignment sample set. Thirdly, there are the full multi-turn dialogue records generated during the actual execution of collaborative tasks within each group collaboration container, as well as the intermediate process information and final consensus summary captured by the dynamic context management module. These data constitute the social interaction graph. Fourthly, there are real-time resource metrics provided by the underlying infrastructure monitoring system, including the load rate of computing nodes, memory usage, network bandwidth consumption, and internal cost coefficients calculated based on cloud service pricing models. These data constitute resource status signals. All data is de-identified before being fed into the engine and is continuously injected in a streaming manner.

[0061] The core algorithm of the evolutionary engine is a multi-layered, iterative optimization framework. Its first layer focuses on privacy-preserving distillation and enhancement of the agent's capability profile. This layer does not directly exchange or centrally store any agent's private experience data; instead, it employs a technique combining federated learning and secure aggregation. Each agent locally maintains a lightweight deep neural network model called the Behavioral Value Network. ,in This represents the task state perceived by the agent (derived from its input context). This represents the action it might take (corresponding to generating a certain output). These are the parameters of the network. The goal of this network is to evaluate the state. Take action The expected long-term utility. Local training utilizes the agent's own experience pool. The loss function is standard temporal difference error. When cross-container knowledge fusion is required, the engine coordinates a round of secure aggregation: each participating agent computes its model parameters locally. Update gradient The gradients are then encrypted using homomorphic encryption before being sent to the secure aggregator. The aggregator calculates a weighted average of the gradients from all participants in the encrypted state. This is then decrypted and broadcast. Each agent applies this average gradient to update its local model, while adding noise that satisfies differential privacy requirements. ,Right now

[0062] in For learning rate, noise The scale is determined by the privacy budget. Control. Through this process, each agent can absorb the collective experience to improve the accuracy of its own capability assessment without disclosing any original interaction data, thus achieving the evolution of collective intelligence under privacy and security.

[0063] The second layer of the evolutionary engine focuses on robustness verification and mechanism optimization of interaction rules. This part models the generation and evaluation of rule configurations as an optimization problem based on game theory simulation. The system maintains a rule generator network. It describes user intent and a random noise vector As input, output a parameterized rule configuration. This rule It not only includes the logical description on the interface, but also defines a set of mechanism parameters at a deeper level. For example, the shape of the reward function, the voting weight allocation scheme, etc. To evaluate the rules... To assess the performance, the engine launches a lightweight multi-agent simulation environment where the virtual agents' policies are based on the behavioral value network obtained from the first-layer distillation. In this simulation environment, the operation is governed by rules. Define the mechanism and observe the equilibrium state reached after the interaction of virtual intelligent agents. The quality of a rule is determined by a composite utility function. evaluate:

[0064] in, Measurement rules With user intent semantic alignment It is the first Game theory or sociological performance indicators (such as Pareto efficiency, incentive compatibility, consensus speed, etc.) in equilibrium The value below, It is a rule complexity penalty term. These are the weighting coefficients. The parameters are optimized through backpropagation. To maximize The system can automatically synthesize high-quality rules that not only meet the intuitive requirements of users but also have good collaborative characteristics in theory.

[0065] The third layer of the evolutionary engine is responsible for global policy optimization and counterfactual causal exploration for resource awareness. This layer constructs a system-level structural causal model to characterize the causal relationships between system variables. Variables in the model include, but are not limited to, the initial state of resources. The collaborative strategy adopted (Integrating container topology, agent composition, rule configuration, etc.), intermediate process variables (such as message throughput, degree of disagreement), and the final result. (e.g., task quality, total time consumption, resource cost). Based on historical data, the engine uses causal discovery algorithms (such as the score-based NOTEARS method) to learn the causal graph structure and estimate the strength of causal effects. When faced with new collaborative scenarios, the engine utilizes this causal model for counterfactual reasoning and planning. For example, solving problems given resource constraints. And maximize task quality Under the given conditions, the optimal strategy The search problem can be formalized as:

[0066] here This indicates intervention in policy variables within a causal model. After solving this problem, the engine will apply the policy... The process is broken down into specific container construction instructions, agent allocation schemes, and rule configurations, and piloted in small-scale real-world collaborative tasks using a "canary release" model. The new data generated from the pilot, along with its final results, will be immediately fed back as new samples to the causal model and the first-layer experience pool to update model parameters and knowledge, thus forming a complete autonomous evolutionary closed loop from perception to decision-making to verification.

[0067] In summary, this optimized technical solution utilizes a collaborative system autonomous evolution engine, fueled by data generated during the operation of the aforementioned method embodiments. It employs privacy-preserving distillation, game theory mechanism optimization, and causal counterfactual reasoning as core algorithmic tools to construct an intrinsic capability that enables a no-code intelligent agent collaborative system to continuously improve and adapt. This engine seamlessly integrates with the container layer, functional layer, collaborative layer, and knowledge preservation mechanism described in the embodiments, receiving their data and outputting optimized parameters, rules, and strategy suggestions. Together, they achieve a fundamental improvement from static orchestration to dynamic evolution, and from user-driven to system autonomous enhancement.

[0068] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, because according to the embodiments of this application, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are all optional embodiments, and the actions and modules involved are not necessarily essential to this application.

[0069] The above description is merely a preferred embodiment of this application and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of disclosure in this application is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the foregoing disclosed concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features with similar functions disclosed in this application.

Claims

1. A no-code orchestration method based on intelligent agents, characterized in that, The method includes: In response to user configuration operations based on a graphical interface or natural language, a group of collaborative containers is dynamically constructed or modified. The group of collaborative containers is used to logically accommodate multiple intelligent agent functional modules with autonomous decision-making capabilities. In response to a natural language task instruction input to the group collaboration container, the natural language task instruction is parsed through natural language processing to identify the task intent, and a collaborative task sequence is generated based on the identified task intent and the capability description of each intelligent agent functional module in the group collaboration container. The collaborative task sequence defines the tasks, execution order and data flow to be performed by at least two intelligent agent functional modules in the group collaboration container. In response to the interaction rules configured for the group collaboration container, the interaction rules are converted into underlying communication protocol instructions for scheduling message passing and triggering timing between agents, and the agent functional modules in the group collaboration container are driven to perform collaborative operations based on the underlying communication protocol instructions and the collaborative task sequence. During the execution of the collaborative operation, intermediate process information generated within the group collaboration container is captured in real time, and this intermediate process information is added as a dynamic context to the input data of subsequent related intelligent agent functional modules.

2. The method according to claim 1, characterized in that, The dynamic construction or modification of a group of collaborative containers includes: Receive a configuration instruction from a user to associate at least two of the intelligent agent functional modules into the same collaborative group, so as to form the group collaborative container; The group collaboration container is a logical entity that independently maintains the collaboration context between the functional modules of the intelligent agent.

3. The method according to claim 1, characterized in that, Based on the identified task intent and the capability descriptions of the functional modules of each agent within the group collaboration container, a collaborative task sequence is generated, including: The task intent is broken down into multiple sub-tasks; By calculating the semantic similarity between each subtask and the natural language capability description of each agent's functional module, at least one agent functional module is matched for each subtask. Based on the logical or data dependencies between the multiple subtasks, the execution order of each of the functional modules of the executing entity intelligent agent is arranged to form the collaborative task sequence.

4. The method according to claim 1, characterized in that, The step of converting the interaction rules configured for the group collaboration container into underlying communication protocol instructions includes: The graphical interface provides rule configuration elements for defining the speaking order, triggering conditions, or priority strategies among the functional modules of an agent. The rule logic, which is set by the user through the operation of the rule configuration element and is oriented towards the collaborative process description, is mapped to machine-executable protocol instructions that control message queue sorting, communication token allocation, or event listener registration.

5. The method according to claim 4, characterized in that, The rule configuration element includes a configuration block for defining condition triggering logic; The step of mapping the rule logic set by the user through operation of the rule configuration element into machine-executable protocol instructions includes: The state defined by the conditional clause in the conditional triggering logic is converted into the corresponding event listener registration instruction; The actions defined in the execution clauses of the conditional triggering logic are converted into message routing instructions sent to specific intelligent agent functional modules when a corresponding event is detected.

6. The method according to claim 1, characterized in that, The real-time capture of intermediate process information generated within the group collaboration container, and the addition of this intermediate process information as dynamic context to the input data of subsequent related intelligent agent functional modules, includes: Listen to and acquire the natural language conclusions output by any intelligent agent's functional modules during collaborative operations; The natural language conclusion information is inserted into the input prompt information of the designated subsequent intelligent agent functional module.

7. The method according to claim 1, characterized in that, The method further includes: The intermediate process information generated within the group collaboration container is analyzed in real time, and text summaries representing consensus conclusions or key points of disagreement are extracted. Output the text summary, or add the text summary to the input data of a specified intelligent agent functional module.

8. The method according to claim 1, characterized in that, The dynamic construction or modification of a group of collaborative containers also includes: In response to the detection of automated triggering conditions related to a preset purpose of the group collaboration container, the build or modification operation is executed automatically.

9. The method according to claim 3, characterized in that, The method further includes: When a vague or missing parameter is detected in the task intent, a requirement clarification agent function module is driven to interact with the user in natural language to obtain supplementary information. After updating the task intent based on the supplementary information, the disassembly, matching, and orchestration steps are re-executed.

10. The method according to claim 1, characterized in that, The method further includes: Time-sensitive tags are attached to specific knowledge entries associated with the collaborative task sequence, the interaction rules, or the intermediate process information; Based on the comparison result between the current time and the timeliness tag, perform at least one operation in the process of prompting the user or automatically triggering the information update verification process.

Images