An agent workflow construction method and system based on heterogeneous node cooperation, an execution method thereof, and a medium

Abstract

This application relates to a method, system, execution method, and medium for constructing an intelligent agent workflow based on heterogeneous node collaboration, and relates to the field of intelligent agent construction and execution technology. The intelligent agent workflow construction method includes: parsing task scenario requirements, matching and selecting task application nodes in conjunction with a preset standard node library, and marking unresolved elements; arranging task application nodes according to the task execution flow, and constructing a task flow node skeleton in conjunction with node-specific parameters; verifying and filtering unresolved elements, and correcting and filling the task flow node skeleton in conjunction with business logic to generate a visual workflow diagram; in the construction phase, by parsing task requirements, matching application nodes from the standard node library and marking unresolved elements, arranging the node skeleton according to the business flow, and constructing a visual workflow in conjunction with specific parameters; in the execution phase, generating task sequence codes and allocating resources according to node dependencies, determining the anomaly level by real-time monitoring of node running status, and correcting abnormal flows.

Description

Technical Field

[0001] This application relates to the field of intelligent agent construction and execution technology, and in particular to an intelligent agent workflow construction method, system, execution method, and medium based on heterogeneous node collaboration. Background Technology

[0002] With the large-scale application of artificial intelligence technology, intelligent agent systems capable of completing complex business tasks have become the core direction of technology research and development and industrial application. However, the existing intelligent agent development model has significant technical pain points: Developers need to manually connect to different types of AI models, external data sources, third-party platform services, and internal business systems. This involves a large amount of coding work and requires developers to have strong technical skills in multiple fields, resulting in a high technical threshold.

[0003] Most mainstream intelligent agent frameworks adopt fixed single execution logic, which cannot dynamically adjust the execution path according to real-time feedback from business scenarios (such as node execution results and changes in external data), making it difficult to adapt to ever-changing business needs.

[0004] Most intelligent agent applications are custom-developed, and similar functional modules cannot be reused in different projects, resulting in redundant development, low development efficiency, and hindering the accumulation of enterprise-level capabilities.

[0005] The development process is mainly based on code writing, lacking intuitive graphical orchestration tools. Non-technical personnel (such as business personnel and product personnel) find it difficult to participate in the construction and maintenance of intelligent agents, resulting in low efficiency in connecting technology and business requirements.

[0006] Existing patents disclose a method for building intelligent agents based on dynamic workflows, relating to the fields of artificial intelligence and automated process management; including: Step 1: Creating an intelligent agent building system for dynamic workflows; Step 2: Creating workflow nodes through an intelligent agent collaboration module, where workflow nodes achieve collaborative decision-making through a standardized communication protocol; Step 3: Using a real-time status awareness module, recording context information through shared memory, issuing commands to adjust the execution order of workflow nodes and the sub-processes of certain workflow nodes based on the context information, and using a standardized message format to achieve data flow across workflow nodes; Step 4: Using a dynamic workflow engine module, inserting / deleting workflow nodes according to commands during workflow node operation, adjusting nested sub-processes, and dynamically orchestrating workflow nodes; Step 5: Integrating reinforcement learning and a rule engine through a dynamic policy controller module, formulating anomaly self-healing strategies, and presetting threshold rules, while combining a time-series prediction model to automatically inject compensation workflow nodes or switch to backup sub-processes.

[0007] The existing technical solutions mentioned above have the following drawbacks: 1. The existing system can only provide basic functional components and has not solved the core problems of unified orchestration of heterogeneous nodes, visual construction, and dynamic workflow execution, resulting in low efficiency of intelligent agent development, poor scenario adaptability, and high operation and maintenance costs. Summary of the Invention

[0008] To address the shortcomings of existing technologies, the purpose of this application is to provide a method, system, execution method, and medium for constructing intelligent agent workflows based on heterogeneous node collaboration. This method supports the integration of new AI models, third-party platforms, or custom business logic through the hybrid orchestration of heterogeneous nodes. It also adapts to the path adjustment needs of complex business scenarios through dynamic scheduling based on DAG.

[0009] This was achieved using the following technical solutions: Firstly, this application provides a method for constructing and executing an intelligent agent workflow based on heterogeneous node collaboration, including an intelligent agent workflow construction phase and an intelligent agent workflow execution phase: The intelligent agent workflow construction phase includes: Analyze the task scenario requirements, match and select task application nodes based on the preset standard node library, and mark uninterpreted elements; Arrange task application nodes according to the task execution flow, and construct the task flow node skeleton by combining node-specific parameters; Verify and filter uninterpreted elements, and combine them with business logic to correct and fill in the task flow node skeleton, generating a visual workflow diagram; The execution phase of the intelligent agent workflow includes: Based on the dependencies between nodes, the visualized workflow graph is resolved and scheduled to generate task execution sequence codes and determine the execution order of nodes. Based on the node type and the node execution order, execution resources are allocated to the corresponding task application nodes, and a node resource coordination table is generated. Monitor the running status of task application nodes based on task execution sequence codes to determine the level of node abnormal status; Adjust the node resource coordination table according to the node's abnormal state level and correct abnormal workflows.

[0010] By adopting the above technical solution, based on the rule engine and dynamic scheduling algorithm, the construction phase matches application nodes from the standard node library and marks unresolved elements by parsing task requirements, arranges the node skeleton according to the business flow, and builds a visual workflow by combining exclusive parameters; in the execution phase, task sequence codes are generated and resources are allocated according to node dependency parsing, and the abnormality level is determined by real-time monitoring of node running status, and the resource coordination table is dynamically adjusted to correct the abnormal flow, so as to realize the closed-loop management of the whole process from visual orchestration to adaptive execution.

[0011] This application is further configured to: parse task scenario requirements, match and select task application nodes based on a preset standard node library, and mark uninterpreted elements, including: The task scenario requirements are transformed based on the pre-set structured form to obtain the original scenario requirement text; Semantic analysis is performed on the original scenario requirement text to extract key elements of the scenario and form a list of requirement elements. The list of demand elements is classified and transformed according to the element type to obtain atomized demand items; The preset standard node library is parsed, metadata indexes are extracted, and node function tags are recorded; Based on the metadata index, the atomic requirement items are indexed and retrieved to obtain a preliminary set of functional nodes; The initial set of functional nodes is matched and combined based on the node function tags to obtain functional application nodes; The functional application nodes are filtered based on the node constraint parameters to obtain the task application nodes; Bind and associate task application nodes with atomic requirement items, and extract and mark uninterpreted elements.

[0012] By adopting the above technical solution, based on natural language processing and knowledge graph retrieval technology, the task scenario requirements are transformed into raw requirement text through structured forms and semantically parsed to extract key elements and atomize them into standardized requirement items. At the same time, a metadata index and functional tag system are constructed by parsing the standard node library. Through vector retrieval and rule matching mechanisms, the atomic requirement items are indexed and matched with functional tags to select task application nodes that meet the constraint parameters. Finally, the nodes are bound and associated with the requirement items and uninterpreted elements are marked, realizing accurate mapping from fuzzy requirements to executable nodes and full-process traceable parsing.

[0013] This application further specifies: orchestrating task application nodes according to the task execution flow, and constructing a task flow node skeleton by combining node-specific parameters, including: Based on the triggering conditions in the task scenario requirements, the task application nodes are filtered to determine the task start node and task branch turning point nodes. The task application nodes are arranged chronologically according to the business process, and combined with the task start node, a workflow node sequence is generated. The workflow node sequence is logically expanded based on the task branch turning points to generate a global node network. Based on the task execution flow, the global node network is orchestrated to construct node data chains; Based on the node type, the node data chain is associated with node-specific parameters and bound with exception handling logic to generate a task flow node skeleton.

[0014] By adopting the above technical solution, based on workflow engine scheduling and rule matching algorithms, the starting node and branch turning point are determined by parsing the task triggering conditions. The nodes are arranged in sequence according to the business process to form a workflow sequence. Then, a global node network is built through logical expansion. Combined with the operation flow orchestration, a data chain is formed. Finally, exclusive parameters and exception handling logic are bound to the nodes to generate a complete task flow node skeleton with branching and fault tolerance capabilities, realizing the automated orchestration and adaptive expansion of the business process.

[0015] This application further specifies: node-specific parameter association and exception handling logic binding are performed on the node data chain according to the node type to generate a task flow node skeleton, including: Traverse the node data chain to extract the node type identifier and node placeholder sequence number; Based on the node type identifier, template matching is performed on the node type library to obtain the node parameter template; The node parameter template is parsed and categorized to obtain parameter attribute names, which are then filled in with business target requirements to obtain node-specific parameters. Based on the node data source and global data structure, node-specific parameters are mapped to construct node mapping parameter key-value pairs; Anomaly simulations are performed on the node data chain based on node type and business importance to determine the node anomaly level; Based on the node anomaly level, perform emergency handling for each task application node and determine the anomaly handling logic; Based on the node placeholder sequence number, the node mapping parameter key-value pairs and exception handling logic are reconstructed to obtain the task flow node skeleton.

[0016] By adopting the above technical solution, type identifiers are extracted and associated with parameter templates based on node parsing and template matching algorithms. Emergency handling logic is bound to the rule engine and anomaly level judgment. Finally, the task flow node skeleton is generated using mapping and reconstruction algorithms. This achieves automated configuration of node parameters and precise binding of anomaly responses, significantly improving the robustness of process construction and development efficiency.

[0017] This application is further configured to: verify and filter uninterpreted elements, and, in conjunction with business logic, correct and populate the task flow node skeleton to generate a visual workflow diagram, including: Based on the business scenario, the uninterpreted elements are judged, and the necessity and feasibility of the elements are calculated. If neither of them is within the corresponding threshold range, the currently undeciphered element is determined to be a noise element, and matching is performed according to the preset global substitution lexicon to calculate the semantic ambiguity. If the semantic ambiguity is greater than the preset ambiguity threshold, the current noisy elements are removed and the valid elements are aggregated. No, then the effective elements are classified and their substitution relationships are determined to identify element priorities and substitute elements; Based on the business logic and the priority of elements, the task application nodes in the task flow node skeleton are evaluated to determine the node fusion level. Based on the node fusion level, substitute or effective elements are fused with the task flow node skeleton to obtain an initial workflow diagram; Configure parameters and map data for the initial workflow diagram, and then visualize it to obtain a visual workflow diagram.

[0018] By adopting the above technical solutions, business elements are screened and graded based on element evaluation and semantic matching algorithms, node skeletons are integrated through rule engine and priority sorting, and workflow diagrams are generated using parameter mapping and visualization rendering technology. This achieves automated construction and intuitive presentation of business processes, significantly improving design efficiency and logical accuracy.

[0019] This application further specifies: monitoring the running status of task application nodes based on task execution sequence codes, and determining the abnormal status level of the nodes, including: Decouple the task execution sequence code and extract the instance identifier, node sequence number, and inter-node dependencies; Based on the node sequence number, monitor the running status of the task application nodes and extract node running data; Based on the preset instance data threshold and instance identifier, the node running data is judged and abnormal task nodes are filtered out. Analyze the error logs, output information, or exception stacks of abnormal task nodes to determine the type of node exception; The initial abnormal state level is determined by comparing the pre-defined abnormality level rules with the node abnormality type. Based on node attributes and inter-node dependencies, the initial abnormal state level is globally corrected to determine the abnormal state level of each node.

[0020] By adopting the above technical solution, node operation data is extracted and anomalies are identified based on sequence parsing and threshold screening algorithms. By combining feature analysis with dependency association rules for level determination and global correction, automated and refined monitoring and classification of task node anomalies are realized, improving system observability and fault response efficiency.

[0021] Secondly, this application also provides an intelligent agent workflow construction system based on heterogeneous node collaboration, which adopts the following technical solution: A system for constructing intelligent agent workflows based on heterogeneous node collaboration, used to implement methods for constructing and executing intelligent agent workflows, includes: The node matching module is used to parse task scenario requirements, match and select task application nodes by combining a preset standard node library, and mark uninterpreted elements. The node orchestration module is used to orchestrate task application nodes according to the task execution flow and, in conjunction with node-specific parameters, construct the task flow node skeleton. The workflow construction module is used to verify and filter uninterpreted elements, combine business logic to correct and fill in the task flow node skeleton, and generate a visual workflow diagram. The interpretation and scheduling module is used to parse and schedule the visual workflow diagram based on the dependencies between nodes, generate task execution sequence codes, and determine the execution order of nodes. The resource allocation module is used to allocate execution resources to the corresponding task application nodes according to the node type and the node execution order, and generate a node resource coordination table. The monitoring and debugging module is used to monitor the running status of task application nodes based on task execution sequence codes, and to correct abnormal workflows in conjunction with the node resource coordination table.

[0022] By adopting the above technical solution, nodes are selected based on requirement analysis and template matching algorithms, a visual flow graph is constructed through rule orchestration and semantic correction, execution sequences are generated and resources are allocated collaboratively using dependency analysis and resource scheduling algorithms, and finally, the workflow is corrected through real-time monitoring and anomaly detection, thereby realizing the automated construction and intelligent operation and maintenance of task processes, improving execution efficiency and system stability.

[0023] Thirdly, this application also provides an electronic device, comprising: One or more processors; Memory, used to store one or more programs; When one or more programs are executed by one or more processors, the one or more processors implement any of the methods in the above scheme.

[0024] Fourthly, this application also provides a storage medium storing at least one instruction, at least one program, code set, or instruction set, wherein the at least one instruction, at least one program, code set, or instruction set is loaded and executed by a processor to implement the intelligent agent workflow construction method based on heterogeneous node collaboration as described above.

[0025] In summary, the beneficial technical effects of this application are as follows: Based on sequence parsing and threshold filtering algorithms, node operation data is extracted and anomalies are identified. By combining feature analysis with dependency association rules, level determination and global correction are performed, realizing automated, refined monitoring and classification of task node anomalies, improving system observability and fault response efficiency. By constructing a visual flow graph through rule orchestration and semantic correction, and using dependency analysis and resource scheduling algorithms to generate execution sequences and coordinate resource allocation, the workflow is finally corrected through real-time monitoring and anomaly detection, thus achieving automated construction and intelligent operation and maintenance of task processes, improving execution efficiency and system stability. Attached Figure Description

[0026] Figure 1 This is a schematic diagram of the overall process of constructing and executing the intelligent agent workflow in this application; Figure 2 This is a flowchart illustrating the automated processing workflow for intelligent customer service work orders in this application. Figure 3 This is a flowchart illustrating step S6 in the execution phase of the intelligent agent workflow in this application. Figure 4 This is a schematic diagram of the intelligent agent workflow construction system in this application; Figure 5 This is a schematic diagram of the workflow construction and execution of the general intelligent agent in this application. Detailed Implementation

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

[0028] Reference Figure 1 This application discloses a method for constructing an agent workflow based on heterogeneous node collaboration, comprising an agent workflow construction phase and an agent workflow execution phase: The intelligent agent workflow construction phase includes: S1: Analyze the task scenario requirements, match and select task application nodes based on the preset standard node library, and mark uninterpreted elements; S2: Arrange task application nodes according to the task execution flow, and construct the task flow node skeleton by combining node-specific parameters; S3: Verify and filter uninterpreted elements, and combine them with business logic to correct and fill in the task flow node skeleton, generating a visual workflow diagram; The execution phase of the intelligent agent workflow includes: S4: Based on the dependencies between nodes, resolve and schedule the visual workflow graph, generate task execution sequence codes, and determine the execution order of nodes; S5: Allocate execution resources to the corresponding task application nodes based on the node type and the node execution order, and generate a node resource coordination table; S6: Monitor the running status of the task application node based on the task execution sequence code and determine the abnormal status level of the node; S7: Adjust the node resource coordination table according to the node's abnormal state level and correct abnormal workflows.

[0029] In this embodiment, refer to Figure 2 In the intelligent agent workflow construction phase, the system first analyzes the business requirements for automatic processing of intelligent customer service work orders. When a new work order is generated by the work order system, the processing flow needs to be automatically triggered. Based on the preset standard node library, the system matches and selects "work order trigger node", "AI intent recognition node", "condition judgment node", "order query platform node", "AI reply generation node", "supervisor approval MCP node", "sentiment analysis AI node", "work order update platform node", "user notification platform node" and "log data writing node". At the same time, it marks any uninterpreted elements, such as the differences in approval paths for different complaint types. Then, according to the natural flow of work order processing, the trigger node is placed at the beginning, and the application nodes are arranged in the logical order of "intent recognition → condition branch → branch processing → convergence → work order update and notification → log recording". The task flow node skeleton is constructed by combining node-specific parameters (such as API call timeout settings and sentiment intensity judgment thresholds). By verifying and filtering historical work order processing logs, the specific rules for uninterpreted elements are clarified, and finally, a visual workflow diagram containing complete business logic is generated.

[0030] After entering the intelligent agent workflow execution phase, the system parses and schedules the flow graph based on the data dependencies between nodes: when the work order system generates a new work order, the process is automatically triggered. The generated task execution sequence code clearly indicates that the AI ​​node first reads the work order description to perform intent recognition, and then enters the corresponding branch based on the recognition result (refund / complaint / inquiry). In the refund branch, the platform node calling the order system API must wait for the AI ​​intent recognition to complete, and the AI ​​response generation node must wait for the order information to be returned. In the complaint branch, the sentiment analysis node must execute immediately after intent recognition. If the sentiment is intense, it directly jumps to the manual processing node; otherwise, it executes the automatic processing logic. The system allocates execution resources according to node type—GPU computing resources are allocated to AI nodes, API call thread pools are allocated to platform nodes, and the supervisor intelligent agent interaction channel is allocated to MCP nodes. A node resource coordination table is generated to ensure that resources do not conflict when multiple branches are running in parallel. During execution, the system monitors the operational status of each node in real time. When the sentiment analysis node in the complaint branch detects intense user emotions, it determines the status level as "moderately abnormal." The system immediately adjusts the node resource coordination table to allocate priority human agent resources for the complaint and corrects the original automatic processing workflow, skipping the automatic reply logic and directly jumping to the human processing node. After all branches converge, the platform nodes synchronously update the work order system and send user notifications. The data nodes write the complete processing record to the log database, realizing fully automated and intelligent processing from work order triggering to closed-loop archiving.

[0031] Preferably, step S1 includes: The task scenario requirements are transformed based on the pre-set structured form to obtain the original scenario requirement text; Semantic analysis is performed on the original scenario requirement text to extract key elements of the scenario and form a list of requirement elements. The list of demand elements is classified and transformed according to the element type to obtain atomized demand items; The preset standard node library is parsed, metadata indexes are extracted, and node function tags are recorded; Based on the metadata index, the atomic requirement items are indexed and retrieved to obtain a preliminary set of functional nodes; The initial set of functional nodes is matched and combined based on the node function tags to obtain functional application nodes; The functional application nodes are filtered based on the node constraint parameters to obtain the task application nodes; Bind and associate task application nodes with atomic requirement items, and extract and mark uninterpreted elements.

[0032] In this embodiment, the standard node library consists of pre-defined, standardized, and reusable node types. Each node defines a unified input / output interface and execution logic, covering the full-scenario requirements of the intelligent agent workflow, including: AI Node: Encapsulates the calling logic of various large language models (GPT-4, Claude, domestic large models, etc.), supports configuration of model type, prompt word template, temperature parameters, etc., and can integrate AI capabilities such as vector retrieval and thought chain to realize natural language understanding, generation, reasoning and other functions.

[0033] MCP Node: Based on the multi-agent communication protocol, it realizes structured message passing between different agents, supports interactive modes such as competition, cooperation, and review, and completes the collaborative scheduling between multiple agents; the multi-agent communication logic of the MCP node can be replaced by a publish / subscribe message queue (RabbitMQ, Kafka) or an Actor model framework (Ray) to realize communication and cooperation between agents.

[0034] Platform Nodes: Encapsulate the calling logic of common platforms / systems such as DingTalk, Lark, Salesforce, databases, and API gateways, including standardized operations such as "sending DingTalk messages" and "querying CRM customer data," eliminating the need for redundant development of integration logic.

[0035] Plugin nodes: Support user-defined extensions. Specific business logic (such as industry-specific calculations or customized data processing) can be encapsulated into reusable nodes by writing Python functions or configuration files.

[0036] Logical nodes: contain control flow logic such as conditional statements (IF / ELSE), loops (FOR / WHILE), parallel execution, and wait / delay, used to define the execution rules and branches of the workflow.

[0037] Data nodes cover the entire data lifecycle, including data input (manual input, file upload), data transformation (JSON parsing, format conversion), and data output (saving to database, generating reports). The internal definition and storage format of the workflow can use YAML, XML, or a custom domain-specific language (DSL). The visual orchestrator is responsible for the bidirectional conversion of graphical representation and format.

[0038] Preferably, step S2 includes: S21: According to the task The triggering conditions in the scenario requirements filter the task application nodes to determine the task start node and task branch turning point; S22: Arrange the task application nodes in chronological order according to the business process, and generate a workflow node sequence by combining the task start node; S23: Logically expand the workflow node sequence based on the task branch turning points to generate a global node network; S24: Arrange nodes in the global node network according to the task execution flow and build node data chains; S25: Based on the node type, associate node-specific parameters and bind exception handling logic to the node data chain to generate the task flow node skeleton.

[0039] In this embodiment, during the workflow construction phase of the customer service work order intelligent agent, the system first filters the preset standard node library according to the trigger condition defined in the task scenario requirements—"automatically start when the work order system status field changes to 'pending' and the priority is ≥3"—to determine the "work order status monitoring node" as the task start node, and identifies the "conditional branch node after intent recognition" and the "jump node after sentiment analysis" as task branch turning points. Subsequently, based on the standard business process of "receiving work orders → understanding requests → classifying and handling → result feedback → archiving records", the system arranges the selected "work order reading node", "AI intent recognition node", "order query node", "AI reply generation node", "supervisor approval node", "sentiment analysis node", "work order update node", "user notification node" and "log writing node" in chronological order, and generates an initial workflow node sequence in combination with the task start node.

[0040] Next, using the "conditional branch node after intent recognition" and the "jump node after sentiment analysis" as core turning points, the node sequence is logically expanded—extending the "order query → reply generation → supervisor approval" subsequence after the refund branch, and splitting into two sub-paths after the complaint branch: "intense emotion → manual handling" and "stable emotion → automatic reply," thus generating a global node network covering all possible business paths. Based on the actual operational flow of the work order from generation to closure, the global node network is arranged layer by layer, clarifying the input and output dependencies between each node, and constructing an interlocking node data chain. Finally, based on node type—AI nodes are associated with deep learning model version numbers and timeout threshold parameters, platform nodes are associated with API endpoints and retry mechanisms, MCP nodes are associated with approval agent identifiers and timeout escalation rules, and data nodes are associated with database table names and write conflict handling logic—exclusive parameters and exception handling logic are bound to each node in the data chain, ultimately generating a complete, logically rigorous, and dynamically expandable task flow node skeleton.

[0041] Preferably, step S25 includes: Traverse the node data chain to extract the node type identifier and node placeholder sequence number; Based on the node type identifier, template matching is performed on the node type library to obtain the node parameter template; The node parameter template is parsed and categorized to obtain parameter attribute names, which are then filled in with business target requirements to obtain node-specific parameters. Based on the node data source and global data structure, node-specific parameters are mapped to construct node mapping parameter key-value pairs; Anomaly simulations are performed on the node data chain based on node type and business importance to determine the node anomaly level; Based on the node anomaly level, perform emergency handling for each task application node and determine the anomaly handling logic; Based on the node placeholder sequence number, the node mapping parameter key-value pairs and exception handling logic are reconstructed to obtain the task flow node skeleton.

[0042] In this embodiment, the existing node data chain is first deeply traversed to extract the node type identifier (such as "AI intent recognition node", "order query platform node", "supervisor approval MCP node") and its placeholder sequence number in the chain for each task application node. Then, based on the extracted node type identifier, template matching is performed in a preset node type library to retrieve the standard node parameter template corresponding to each node. For example, the AI ​​node template includes parameters such as "model version number", "timeout threshold", and "confidence threshold", while the platform node template includes parameters such as "API endpoint", "number of retries", and "request timeout". The system parses and classifies these parameter templates item by item to obtain specific parameter attribute names, and accurately fills them with business target requirements—such as a refund query API response time of 500ms and an emotional intensity threshold of 0.85—to generate unique parameters for each node. Finally, based on the data source of each node (such as the order database of the work order system and the user historical behavior database), the parameters are then accurately filled in. The system employs a globally unified data structure specification, mapping node-specific parameters to standard node mapping parameter key-value pairs to ensure consistent data format across nodes. Based on this, the system performs anomaly simulations of the node data chain according to node type (e.g., core decision nodes, ordinary execution nodes) and their importance in the business process (e.g., intent recognition errors leading to overall process deviations). This simulation includes scenarios such as AI node timeouts, API call failures, and unresponsive approval nodes, determining the potential anomaly levels (critical, severe, and general) for each node. According to a pre-defined anomaly level and emergency strategy mapping table, corresponding anomaly handling logic is bound to each task application node. For example, a critical level triggers process rollback and notifies the administrator; a severe level starts a backup node and retryes three times; and a general level logs and continues execution. Finally, based on the node placeholder sequence number, the system systematically reconstructs and encapsulates the node mapping parameter key-value pairs and anomaly handling logic, generating a complete, parameter-accurate, and self-healing task flow node skeleton.

[0043] Preferably, step S3 includes: Based on the business scenario, the uninterpreted elements are judged, and the necessity and feasibility of the elements are calculated. If neither of them is within the corresponding threshold range, the currently undeciphered element is determined to be a noise element, and matching is performed according to the preset global substitution lexicon to calculate the semantic ambiguity. If the semantic ambiguity is greater than the preset ambiguity threshold, the current noisy elements are removed and the valid elements are aggregated. No, then the effective elements are classified and their substitution relationships are determined to identify element priorities and substitute elements; Based on the business logic and the priority of elements, the task application nodes in the task flow node skeleton are evaluated to determine the node fusion level. Based on the node fusion level, substitute or effective elements are fused with the task flow node skeleton to obtain an initial workflow diagram; Configure parameters and map data for the initial workflow diagram, and then visualize it to obtain a visual workflow diagram.

[0044] In this embodiment, a graphical user interface is provided, allowing users to complete workflow construction either through a no-code / low-code method of "drag-and-drop configuration-connection" or through a no-code / low-code method of automatic selection, configuration, and connection by the system. Drag and drop: Select the desired node from the node type library and drag it onto the visualization canvas; Parameter configuration: Configure unique parameters for each node (such as model parameters for AI nodes and API keys for platform nodes). Process definition: Define the data flow and execution order between nodes by connecting lines to form a visual workflow diagram.

[0045] In this embodiment, during the workflow construction phase of the customer service work order intelligent agent, the system detects the undeciphered element "product recall consultation" when parsing the business scenario. Its element necessity (threshold 0.6) is calculated to be 0.85 and its element feasibility (threshold 0.5) to be 0.92, both exceeding the thresholds. Therefore, it is determined to be a valid element rather than noise. Subsequently, based on the business logic, the correlation between this element and the existing "complaint handling" node is evaluated, determining its priority to be high. It is then merged with the "consultation query" node to generate an initial workflow diagram. Finally, the user selects "recall query API node" and "AI response generation node" from the node type library through a graphical interface by dragging and dropping, configures exclusive parameters (such as API key and model version), and defines the data flow and execution order through connecting lines to complete the construction of the visual workflow diagram.

[0046] Preferably, refer to Figure 3 Step S6 includes: A: Decouple the task execution sequence code and extract the instance identifier, node sequence number, and inter-node dependencies; B: Monitor the running status of task application nodes according to node sequence number and extract node running data; C: Based on the preset instance data threshold and instance identifier, judge the node running data and filter out abnormal task nodes; D: Analyze the error logs, output information, or exception stacks of the abnormal task nodes to determine the type of node exception; E: Based on the preset anomaly level rules and node anomaly types, the initial anomaly state level is determined; F: Based on node attributes and inter-node dependencies, the initial abnormal state level is globally corrected to determine the abnormal state level of the node.

[0047] In this embodiment, during the workflow execution phase of the customer service work order intelligent agent, the system first decouples the task execution sequence code of "Work Order-20250319-008" and extracts the instance identifier "CASE008", node sequence number (1-Intent Recognition, 2-Order Query, 3-Response Generation, 4-Work Order Update), and the dependencies between nodes (e.g., the order query node can only be executed when intent recognition is completed and the intent is "refund"). Subsequently, the system monitors the running status of the task application nodes in real time according to the node sequence number, and continuously extracts node running data such as response time, output data integrity, and resource utilization of each node. When the order query node is executed, if its instance runtime exceeds the preset 800ms threshold and the output data is empty, the system determines the node as an abnormal task node based on the instance identifier.

[0048] Next, the system analyzed the error logs of the node and found an exception record of "API connection timeout," determining the node's exception type to be "external service call failure." Based on the preset exception level rules (fatal: process interrupted and unrecoverable, severe: manual intervention required, normal: automatic retry possible, minor: only warning recorded), "external service call failure" was compared with the rule base and initially classified as a "severe" exception. However, since this node is a core data source node and its subsequent node "reply generation" has a strong data dependency on it, the system globally corrected the initial exception level based on the dependencies between nodes, ultimately determining the node's exception status level to be "fatal," immediately triggering workflow suspension, notifying the supervisor to intervene, and initiating the backup data source query process.

[0049] Reference Figure 4 A smart agent workflow construction system based on heterogeneous node collaboration, applied to the above construction and execution methods, includes: The node matching module is used to parse task scenario requirements, match and select task application nodes by combining a preset standard node library, and mark uninterpreted elements. The node orchestration module is used to orchestrate task application nodes according to the task execution flow and, in conjunction with node-specific parameters, construct the task flow node skeleton. The workflow construction module is used to verify and filter uninterpreted elements, combine business logic to correct and fill in the task flow node skeleton, and generate a visual workflow diagram. The interpretation and scheduling module is used to parse and schedule the visual workflow diagram based on the dependencies between nodes, generate task execution sequence codes, and determine the execution order of nodes. In this embodiment, the interpretation and scheduling module, as the core execution module of the system, is responsible for converting the visualized workflow into executable tasks and completing the scheduling, including: Parser: Parses the workflow configuration (JSON format or DAG) generated by the visual orchestrator into an internal task sequence that the system can recognize; Scheduler: Based on the dependencies between nodes, it dynamically schedules the execution order of nodes and supports multiple execution modes such as synchronous, asynchronous, and parallel. Runtime Context Manager: Maintains global variables, intermediate results, and node states during workflow execution, ensuring accurate data transfer and sharing between heterogeneous nodes.

[0050] The resource allocation module is used to allocate execution resources to the corresponding task application nodes according to the node type and the node execution order, and generate a node resource coordination table. In this embodiment, the resource allocation module includes a node executor cluster, which is a collection of executors composed of local services or distributed cloud functions. It dynamically allocates execution resources according to the node type and is responsible for executing the business logic of each node (such as AI nodes calling large models and platform nodes calling external APIs). It supports elastic scaling. The node executor cluster can adopt a serverless architecture and deploy the node execution logic as cloud functions (such as AWS Lambda) to achieve elastic scaling and pay-as-you-go pricing.

[0051] The monitoring and debugging module is used to monitor the running status of task application nodes based on task execution sequence codes, and to correct abnormal workflows in conjunction with the node resource coordination table.

[0052] In this embodiment, the monitoring and debugging module is used to achieve observability throughout the entire lifecycle of workflow execution: Real-time monitoring: Displays the overall execution progress of the workflow, the input / output data of each node, the execution status (success / failure / in progress), the time consumed, and the resource consumption; Debugging capabilities: Provides breakpoint debugging, single-step execution, variable viewing and other functions to support quick problem location and troubleshooting; Exception handling: Records node execution failure information and can automatically handle exceptions according to preset strategies (retry, skip, terminate). Example

[0053] Reference Figure 5 The construction and execution of a general intelligent agent workflow includes: (1) Construction phase Step S201: Users drag and drop the required nodes from the node type library onto the canvas through the visual workflow orchestrator to complete the initial node selection; Step S202: The user configures personalized parameters for each node (such as prompt words for AI nodes, target interface addresses for platform nodes, and judgment conditions for logical nodes). Step S203: Users define the execution order and data dependencies between nodes through connection lines to form a complete visual workflow diagram, which awaits triggering after construction is complete.

[0054] (2) Execution phase Step S204: The user triggers workflow execution (manual trigger or event trigger, such as "new work order creation"), and the parser parses the workflow graph into an executable task DAG; Step S205: The scheduler distributes ready node tasks to the node executor cluster based on the node dependency relationship of DAG; Step S206: The executor cluster executes the corresponding logic according to the node type (AI nodes call the large model, MCP nodes complete agent communication, platform nodes call external services, etc.). Step S207: The runtime context manager collects the output data of each node and passes it to the downstream nodes as input according to their dependencies; Step S208: The monitoring and debugging module updates the execution status in real time. If a node fails to execute, the exception is handled according to the preset strategy. Step S209: After all nodes have completed their execution, the workflow ends, and the data nodes save the final results to a specified location (such as a database) or return them to the user.

[0055] An electronic device, comprising: One or more processors; Memory, used to store one or more programs; When one or more programs are executed by one or more processors, the one or more processors implement any of the methods in the above scheme.

[0056] A storage medium storing at least one instruction, at least one program, code set, or instruction set, wherein the at least one instruction, at least one program, code set, or instruction set is loaded and executed by a processor to implement the agent workflow construction method based on heterogeneous node collaboration as described above.

[0057] The embodiments described in this specific implementation are preferred embodiments of this application and are not intended to limit the scope of protection of this application. Therefore, all equivalent changes made in accordance with the structure, shape and principle of this application should be covered within the scope of protection of this application.

Claims

1. A method for constructing an intelligent agent workflow based on heterogeneous node collaboration, characterized in that, include: Analyze the task scenario requirements, match and select task application nodes based on the preset standard node library, and mark uninterpreted elements; The task application nodes are arranged according to the task execution flow, and the task flow node skeleton is constructed by combining the node-specific parameters. Verify and filter the uninterpreted elements, and combine them with business logic to correct and fill in the task flow node skeleton, generating a visual workflow diagram.

2. The method for constructing an intelligent agent workflow based on heterogeneous node collaboration according to claim 1, characterized in that, The parsing task scenario requirements, combined with a preset standard node library for matching and selecting task application nodes, mark unparsed elements, including: The task scenario requirements are transformed based on the pre-set structured form to obtain the original scenario requirement text; Semantic analysis is performed on the original scenario requirement text to extract key elements of the scenario and form a list of requirement elements. The list of demand elements is classified and transformed according to the element type to obtain atomized demand items; The preset standard node library is parsed, metadata indexes are extracted, and node function tags are recorded; Based on the metadata index, the atomic requirement items are indexed and retrieved to obtain a preliminary set of functional nodes; The preliminary set of functional nodes is matched and combined according to the node function tags to obtain functional application nodes; The functional application nodes are filtered according to the node constraint parameters to obtain the task application nodes; The task application nodes are bound and associated with the atomic requirements, and uninterpreted elements are extracted and marked.

3. The method for constructing an intelligent agent workflow based on heterogeneous node collaboration according to claim 1, characterized in that, The process of arranging the task application nodes according to the task execution flow and constructing the task flow node skeleton by combining node-specific parameters includes: Based on the triggering conditions in the task scenario requirements, the task application nodes are filtered to determine the task start node and task branch turning point nodes. The task application nodes are arranged chronologically according to the business process, and a workflow node sequence is generated by combining the task start node. Based on the task branch turning points, the workflow node sequence is logically expanded to generate a global node network; The global node network is orchestrated according to the task execution flow to construct node data chains; Based on the node type, the node data chain is associated with node-specific parameters and bound with exception handling logic to generate a task flow node skeleton.

4. The method for constructing an intelligent agent workflow based on heterogeneous node collaboration according to claim 3, characterized in that, The process of associating node-specific parameters and binding exception handling logic to the node data chain according to node type to generate a task flow node skeleton includes: Traverse the node data chain to extract the node type identifier and node placeholder sequence number; Based on the node type identifier, template matching is performed on the node type library to obtain the node parameter template; The node parameter template is parsed and categorized to obtain parameter attribute names, which are then filled in with business target requirements to obtain node-specific parameters. Based on the node data source and global data structure, the node-specific parameters are mapped to construct node mapping parameter key-value pairs; Anomaly simulations are performed on the node data chain based on node type and business importance to determine the node anomaly level; Based on the node anomaly level, perform emergency handling for each task application node and determine the anomaly handling logic; Based on the node placeholder sequence number, the node mapping parameter key-value pairs and the exception handling logic are reconstructed to obtain the task flow node skeleton.

5. The method for constructing an intelligent agent workflow based on heterogeneous node collaboration according to claim 1, characterized in that, The process of verifying and filtering the undeciphered elements, and combining this with business logic to correct and fill in the task flow node skeleton, generates a visual workflow diagram, including: Based on the business scenario, the uninterpreted elements are judged, and the necessity and feasibility of the elements are calculated. If neither of them is within the corresponding threshold range, the currently undeciphered element is determined to be a noise element, and matching is performed according to the preset global substitution lexicon to calculate the semantic ambiguity. If the semantic ambiguity is greater than a preset ambiguity threshold, then the current noisy elements are removed and the valid elements are aggregated. If not, then the effective elements are classified and substituted, and the element priority and substitute elements are determined. Based on the business logic and the priority of the aforementioned elements, the task application nodes in the task flow node skeleton are evaluated to determine the node fusion level. Based on the node fusion level, the alternative elements or the effective elements are fused with the task flow node skeleton to obtain an initial workflow diagram; The initial workflow diagram is configured with parameters and mapped with data, and then visualized to obtain a visualized workflow diagram.

6. A smart agent workflow construction system based on heterogeneous node collaboration, used to implement the construction method as described in any one of claims 1-5, characterized in that, include: The node matching module is used to parse task scenario requirements, match and select task application nodes by combining a preset standard node library, and mark uninterpreted elements. The node orchestration module is used to orchestrate the task application nodes according to the task execution flow, and to construct the task flow node skeleton by combining node-specific parameters; The workflow construction module is used to verify and filter the uninterpreted elements, and to modify and fill the task flow node skeleton in combination with business logic to generate a visual workflow diagram.

7. The method for constructing an intelligent agent workflow based on heterogeneous node collaboration according to claim 6, characterized in that, The intelligent agent workflow construction system also includes: The interpretation and scheduling module is used to parse and schedule the visual workflow diagram based on the dependencies between nodes, generate task execution sequence codes, and determine the execution order of nodes. The resource allocation module is used to allocate execution resources to the corresponding task application nodes according to the node type and the execution order of the nodes, and generate a node resource coordination table. The monitoring and debugging module is used to monitor the running status of the task application node based on the task execution sequence code, and correct abnormal workflows in conjunction with the node resource coordination table.

8. A method for executing an intelligent agent workflow based on heterogeneous node collaboration, applied to the construction system as described in any one of claims 6-7, characterized in that, include: Based on the dependencies between nodes, the visualized workflow graph is resolved and scheduled to generate task execution sequence codes and determine the execution order of nodes. Based on the node type and the node execution order, execution resources are allocated to the corresponding task application nodes, and a node resource coordination table is generated. Monitor the running status of the task application node based on the task execution sequence code, and determine the abnormal status level of the node; Adjust the node resource coordination table according to the node's abnormal state level and correct abnormal workflows.

9. The method for constructing an intelligent agent workflow based on heterogeneous node collaboration according to claim 8, characterized in that, The step of monitoring the running status of the task application node based on the task execution sequence code and determining the node abnormal status level includes: Decouple the task execution sequence code and extract the instance identifier, node sequence number, and inter-node dependencies; Based on the node sequence number, the running status of the task application nodes is monitored, and node running data is extracted; Based on a preset instance data threshold and the instance identifier, the node running data is judged to filter out abnormal task nodes; The error logs, output information, or exception stacks of the abnormal task nodes are parsed to determine the type of node exception. The initial abnormal state level is determined by comparing the node abnormality type with the preset abnormality level rules. Based on node attributes and inter-node dependencies, the initial abnormal state level is globally corrected to determine the node abnormal state level.

10. A storage medium storing at least one instruction, at least one program, a code set, or an instruction set, wherein the at least one instruction, the at least one program, the code set, or the instruction set is loaded and executed by a processor to implement the agent workflow construction method as claimed in any one of claims 1 to 5, and / or the agent workflow execution method as claimed in any one of claims 8 to 9.

Images