Business process automation execution method and system based on multi-agent cooperation

Abstract

This application provides a method and system for automating business process execution based on multi-agent collaboration, relating to the fields of intelligent automation and multi-agent collaboration. It receives configuration request data containing text descriptions, image materials, and numerical range settings from a multi-channel platform; constructs an initial state node for a collaborative task carrying task constraints and completion benchmarks; and writes it into an agent collaboration network. A task scheduling agent reads the node to generate a distribution path and feedback channel, sending data fragments to a dedicated processing agent. The feedback channel receives feedback messages containing status flags, output data packets, and exception reason codes; the deviation between the status flags and the completion benchmarks is compared to generate a state transition trigger instruction; based on this state transition trigger instruction, a transition path is selected to update the initial node to a successor node and rearrange the distribution path; the output data packet is used as the context constraint for subsequent execution. This invention achieves dynamic adaptive execution of business processes and the transmission of context constraints.

Description

Technical Field

[0001] This application relates to the fields of intelligent automation and multi-agent collaboration technology, and more specifically, to a method and system for automating business process execution based on multi-agent collaboration. Background Technology

[0002] As enterprises deepen their digital transformation, business process automation has become a core means of improving operational efficiency. Existing business process automation solutions typically use preset rule engines or fixed orchestration scripts to drive task execution. These solutions have significant limitations when facing heterogeneous configuration requests from multiple channel platforms. Specifically, when receiving configuration requests from multiple channel platforms, existing technologies often parse different modalities of data, such as text descriptions, image materials, and numerical settings, independently, lacking a mechanism to uniformly map multiple data modalities into an executable task structure, resulting in insufficient information integrity during the task initialization phase.

[0003] For example, existing solutions often employ a linear task distribution model, where tasks are sequentially passed to each processing unit in a fixed order. This approach cannot dynamically adjust the task distribution path based on real-time status feedback during task execution. If an anomaly occurs in a processing stage or the output deviates from expectations, the system typically has to halt the entire process and trigger manual intervention. It lacks the ability to automatically generate state transition paths based on state deviations and drive tasks to evolve towards subsequent state nodes. Furthermore, in existing technologies, information transmission between processing units is mostly unidirectional, meaning that the output data of preceding processing units cannot be used as contextual constraints for subsequent processing units. This fragments the semantic relationships between processing stages, severely restricting the adaptive execution capability and fault-tolerant recovery efficiency of business processes in complex and ever-changing scenarios. Summary of the Invention

[0004] In view of this, the purpose of this application is to provide a method and system for automating business process execution based on multi-agent collaboration.

[0005] According to a first aspect of this application, a method for automating business process execution based on multi-agent collaboration is provided, the method comprising: Receive configuration request data for pending business on a multi-channel platform. The configuration request data includes text description data, image material data, and numerical range setting data. Based on the configuration request data, a collaborative task initial state node is constructed. The collaborative task initial state node is written into a preset agent collaborative network through a task scheduling agent. The collaborative task initial state node carries a set of task constraints and a set of task completion benchmarks. The task scheduling agent performs a status reading operation on the initial state node of the collaborative task, generates a task distribution path sequence and a task status feedback channel identifier for the initial state node of the collaborative task, and sends the task data fragments extracted from the initial state node of the collaborative task along the task distribution path sequence to multiple dedicated processing agents corresponding to the task type. The task execution feedback message is received from the multiple dedicated processing agents on the channel indicated by the task status feedback channel identifier. The task scheduling agent parses the task status flag, task output data packet and task exception reason code from the task execution feedback message, and compares the task status flag with the corresponding benchmark entry in the task completion benchmark set to generate a state transition trigger instruction. Based on the state transition triggering instruction, a corresponding state transition path is selected in the agent cooperative network. The task scheduling agent is driven to update the initial state node of the cooperative task to the subsequent state node of the cooperative task along the state transition path. Under the subsequent state node of the cooperative task, the task distribution path sequence is rearranged based on the task output data packet and the task exception reason code to generate an updated task distribution path sequence. The task output data packet is used as the task context constraint when the multiple dedicated processing agents execute the task again.

[0006] According to a second aspect of this application, a business process automation execution system based on multi-agent collaboration is provided. The business process automation execution system based on multi-agent collaboration includes a machine-readable storage medium and a processor. The machine-readable storage medium stores machine-executable instructions. When the processor executes the machine-executable instructions, the business process automation execution system based on multi-agent collaboration implements the aforementioned business process automation execution method based on multi-agent collaboration.

[0007] Based on any of the above aspects, the technical effect of this application is as follows: First, by unifying the description data, image material data, and numerical range setting data contained in the configuration request data of multi-channel platforms into a collaborative task initial state node carrying a set of task constraints and a set of task completion benchmarks, and writing this collaborative task initial state node into the intelligent agent collaborative network, the initial state of the business process possesses complete multimodal semantic information and quantifiable completion benchmarks. Based on this, the present invention uses a task scheduling intelligent agent to perform a state reading operation on the collaborative task initial state node, dynamically generating a task distribution path sequence and a task status feedback channel identifier, and sending the extracted task data fragments along the path to the corresponding dedicated processing intelligent agent. During execution, the task execution feedback message containing task status flags, task output data packets, and task exception reason codes is received through the task status feedback channel. The task scheduling intelligent agent then matches the task status flags with the corresponding benchmark entries in the task completion benchmark set. By performing deviation comparison and generating state transition trigger instructions, the system can automatically detect the deviation between the task execution state and the expected baseline without human intervention. Based on this deviation, it drives state transitions, updates the initial state node of the collaborative task to the subsequent state node of the collaborative task along the selected state transition path, and rearranges the task distribution path sequence based on the task output data packet and the task exception reason code to generate an updated path. The task output data packet is used as the task context constraint when multiple dedicated processing agents execute the task again, realizing dynamic adaptive adjustment in the business process execution. This allows the output of the preceding processing stage to conditionally guide the execution of the subsequent processing stage in the form of context constraints. A semantically related closed-loop collaborative relationship is formed among the dedicated processing agents, which significantly improves the robustness, adaptability, and execution accuracy of automated business process execution in the face of complex and ever-changing multi-channel configuration scenarios. Attached Figure Description

[0008] Figure 1 A flowchart illustrating the automated execution method for business processes based on multi-agent collaboration provided in an embodiment of this application is shown.

[0009] Figure 2 This is a schematic diagram of the intelligent agent cooperative network and task state evolution process provided in the embodiments of this application.

[0010] Figure 3 This is a schematic diagram of the configuration request data parsing and collaborative task initial structure diagram construction provided in the embodiments of this application.

[0011] Figure 4 This is a schematic diagram of the task distribution, execution, state transition, and path reordering process provided in the embodiments of this application.

[0012] Figure 5This is a schematic diagram of the business process automation execution console interface provided in the embodiments of this application. Detailed Implementation

[0013] Figure 1 This diagram illustrates a flowchart of a business process automation execution method based on multi-agent collaboration provided in this application. The method is applied to a distributed computing environment deploying a task scheduling agent and multiple dedicated processing agents. Both the task scheduling agent and the dedicated processing agents are autonomous software entities running in a containerized runtime environment, communicating with each other via asynchronous message queues. The task scheduling agent is responsible for receiving business configuration requests, constructing task status nodes, generating task distribution path sequences, collecting execution feedback, and driving state transitions. Each dedicated processing agent encapsulates processing logic for specific business fragment types, including a copywriting agent, an image rendering agent, a pricing strategy agent, and an inventory configuration agent. Before executing the business process, the task scheduling agent sends a capability registration query request to each dedicated processing agent through a secure communication channel. Each dedicated processing agent returns a digitally signed capability declaration document. After signing, the task scheduling agent registers the fragment type marker and processing interface address from the capability declaration to the dedicated agent registry. All business data is transmitted and stored in encrypted form within the intelligent agent collaborative network. User-generated original text descriptions and image materials within task fragments are completely erased from the state storage area after the business process is completed, triggered by a data lifecycle termination policy triggered by the task scheduling intelligent agent. The following section details the implementation process of this method using a scenario of configuring a promotional activity on the same e-commerce platform. In this scenario, operations personnel submit a promotional activity configuration request through the multi-channel management backend, including activity text descriptions, product promotional image materials, and promotional price and inventory range settings. The intelligent agent collaborative network automatically completes the end-to-end business process from text layout and image processing to pricing strategy calculation and inventory configuration.

[0014] Step S110: Receive configuration request data for the business to be processed on the multi-channel platform. The configuration request data includes text description data, image material data, and numerical range setting data.

[0015] Operations personnel fill in the activity description text, upload product promotional image files, and set the promotional price range and activity inventory reservation quantity range on the promotional activity creation page of the multi-channel management backend. The multi-channel management backend packages the above three types of data into structured configuration request data. The configuration request data is encoded in JSON data exchange format and sent to the external RESTful application interface endpoint of the task scheduling agent via HTTPS protocol. The top-level JSON object of the configuration request data contains three key-value pairs: the key for the text description data is a nested JSON object containing the activity title string and the activity details description string; the key for the image material data is a nested JSON object containing a list of image file Uniform Resource Locators (URIs) and an image usage label string; the key for the numerical range setting data is a nested JSON object containing product pricing range JSON objects, inventory configuration range JSON objects, and promotional discount range JSON objects. The product pricing range JSON object contains price start boundary value keys and price end boundary value keys; the inventory configuration range JSON object contains inventory reservation start value keys and inventory reservation end value keys; and the promotional discount range JSON object contains discount percentage start value keys and discount percentage end value keys. After receiving the configuration request data, the task scheduling agent performs JSON pattern validation on the JSON data packet. The validation is based on a predefined standard JSON pattern file. After the validation is successful, it returns an HTTP 202 response with a request acceptance confirmation identifier to the multi-channel management backend and writes the configuration request data to the persistent state storage area of ​​the agent's collaborative network.

[0016] Step S120: Construct the initial state node of the collaborative task based on the configuration request data, and write the initial state node of the collaborative task into the preset intelligent agent collaborative network through the task scheduling intelligent agent. The initial state node of the collaborative task carries the set of task constraints and the set of task completion benchmarks.

[0017] After receiving and verifying the configuration request data, the task scheduling agent performs structured parsing and fragmentation of the three types of data in the configuration request data, transforms the business intent into atomic task units that can be executed collaboratively by various dedicated processing agents, and encapsulates them into state nodes carrying execution constraints and verification benchmarks.

[0018] Step S121: Extract text entities from the text description data in the configuration request data to generate a text entity list and a text entity relationship list. The text entity list includes product name entity, activity rule entity, and display text entity. The text entity relationship list describes the applicable relationship between product name entity and activity rule entity and the correspondence between product name entity and display text entity.

[0019] The JSON object corresponding to the value of the copywriting description data (key) in the configuration request data is input into the pre-trained named entity recognition model. The named entity recognition model employs a sequence labeling model based on a transducer bidirectional encoder representation architecture. The backbone network of the model consists of stacked multi-layer transducer encoder layers, each containing a multi-head self-attention sublayer and a feedforward neural network sublayer. The model was fine-tuned on annotated corpora in the e-commerce domain. The training data included promotional activity text samples labeled with three entity types: product name, activity rules, and display text. After segmenting and embedding the input activity title string and activity detail description string, the model outputs the entity category probability distribution corresponding to each segmentation position, taking the category with the highest probability as the entity label for that segmentation position. Segments with consecutive identical entity labels are merged into complete entities. The start and end character offsets and entity text content of the entity in the text are extracted to generate a copywriting entity list. Each record in the copywriting entity list contains the entity text content, entity category label, and the entity's span in the original text. Simultaneously, for any two different entities in the copywriting entity list, their syntactic dependency relationship in the original text is determined. If two entities appear in the same sentence and the shortest dependency path length between them in the syntactic dependency parsing tree is less than a preset dependency distance threshold, a copy entity relationship record is generated. If one entity in the entity pair of the relationship record is a product name entity and the other is an activity rule entity, the relationship type is labeled as an applicable relationship. If one entity in the entity pair of the relationship record is a product name entity and the other is a display text entity, the relationship type is labeled as a corresponding relationship. All relationship records form a copy entity relationship list.

[0020] Step S122: Divide the image material data in the configuration request data into image regions, generate region segmentation boundaries and pixel statistical distribution within the regions, determine the foreground image region and background image region based on the region segmentation boundaries, extract the edge pixel sequence of the foreground object from the foreground image region, and extract the background color fill pattern from the background image region.

[0021] The image file Uniform Resource Locator (URL) list is extracted from the image material data key in the configuration request data. The task scheduling agent sequentially sends GET requests to each URL via an HTTP client, receiving the binary data stream of the image file and decoding it into a three-dimensional pixel value array. The three dimensions of the array correspond to the image height (pixels), image width (pixels), and color channels, respectively. This three-dimensional pixel value array is input into a lightweight semantic segmentation model based on depthwise separable convolution. The encoder of the semantic segmentation model uses a lightweight backbone network pre-trained on the ImageNet dataset, and the decoder uses a feature pyramid upsampling structure, outputting a single-channel segmentation mask with the same spatial resolution as the original image. The value of each pixel in the segmentation mask is the category identifier of the region to which that pixel belongs; foreground object pixels are identified as 1, and background pixels as 0. Connected pixel regions with an identifier of 1 are defined as foreground image regions, and connected pixel regions with an identifier of 0 are defined as background image regions. The pixel boundary between the foreground and background image regions is the region segmentation boundary, stored as an ordered list of pixel coordinates. Histogram statistics are performed on the brightness values ​​of each channel in the RGB color space for all pixels within the foreground image region to generate the pixel statistical distribution within the foreground region. The Canny edge detection algorithm is used to extract edges in the foreground image region. The Canny algorithm first applies Gaussian smoothing filtering to the foreground image region, then calculates the gradient magnitude and direction at each pixel location. The gradient magnitude G = (Gx² + Gy²)^(1 / 2), and the gradient direction θ = arctan(Gy / Gx), where Gx and Gy are the results of Sobel convolution in the horizontal and vertical directions, respectively. Next, non-maximum suppression is performed, retaining pixels with locally maximum gradient magnitudes along the gradient direction. Finally, edge pixels are connected using a double-threshold concatenation method to obtain the foreground object edge pixel sequence. For the background image region, the RGB color values ​​of all pixels are statistically analyzed using mean color values. The arithmetic mean of the brightness values ​​of each channel is taken as the dominant color of the background color fill mode. The background color fill mode is stored in the form of triplets (mean R, mean G, mean B).

[0022] Step S123: Decompose the numerical range setting data in the configuration request data into numerical ranges to generate product pricing range, inventory configuration range and promotional discount range. The product pricing range includes the starting boundary value of the price and the ending boundary value of the price. The inventory configuration range includes the starting value of the inventory reservation and the ending value of the inventory reservation. The promotional discount range includes the starting value of the discount ratio and the ending value of the discount ratio.

[0023] Extract nested JSON objects from the values ​​of data where the key is a numerical range setting in the configuration request data. For the JSON object corresponding to the key "product pricing range," parse the values ​​of the starting and ending price boundary values, organizing these two boundary values ​​into a product pricing range. The lower and upper limits of the range correspond to the values ​​of the starting and ending price boundary values, respectively, and verify that the lower limit is less than or equal to the upper limit. For the JSON object corresponding to the key "inventory configuration range," parse the values ​​of the starting and ending inventory reservation values, organizing these two boundary values ​​into an inventory configuration range, and verify that the starting inventory reservation value is less than or equal to the ending inventory reservation value. For the JSON object corresponding to the key "promotional discount range," parse the values ​​of the starting and ending discount percentage values, organizing these two boundary values ​​into a promotional discount range, verifying that the starting discount percentage is greater than or equal to 0 and the ending discount percentage is less than or equal to 1. The three resulting ranges are temporarily stored in memory as a set of key-value pairs.

[0024] Step S124: Input the text entity list, region segmentation boundary, foreground object edge pixel sequence, background color fill mode, product pricing range, inventory configuration range and promotional discount range into the task fragment generator to generate multiple task fragments. Each task fragment carries a fragment type tag and fragment content data.

[0025] The task fragment generator processes data based on a predefined set of task fragment generation templates. This set includes templates for copywriting layout, image processing, pricing strategies, and inventory configuration. The copywriting layout template takes a list of copywriting entities and a list of relationships between them as input parameters. The generator uses the text content of entities labeled "Display Text Entities" as input and pairs of entities with "Applicable Relationship" as constraints. This generates the first task fragment, tagged as "Copywriting Layout," whose content includes the input text string and the list of constraints. The image processing template takes a region segmentation boundary, a foreground object edge pixel sequence, and a background color fill mode as input parameters. The generator generates the second task fragment, tagged as "Image Processing," whose content includes an ordered list of pixel coordinates for the region segmentation boundary, a foreground object edge pixel sequence, and a triplet value for the background color fill mode. The input parameters for the pricing strategy fragment template are the product pricing range and the promotional discount range. The task fragment generator generates the third task fragment, labeled as "Pricing Strategy," whose content includes the lower and upper limits of the product pricing range and the lower and upper percentages of the promotional discount range. The input parameter for the inventory configuration fragment template is the inventory configuration range. The task fragment generator generates the fourth task fragment, labeled as "Inventory Configuration," whose content includes the lower and upper limits of the inventory configuration range. All generated task fragments are combined into a task fragment list and returned.

[0026] Step S125: Based on the fragment type markers and fragment content data carried by each of the multiple task fragments, determine the execution order and input-output connection relationship between the multiple task fragments, and generate a collaborative task initial structure diagram according to the execution order and input-output connection relationship. Set preconditions for each task fragment in the collaborative task initial structure diagram. The preconditions are the completion status markers of the upstream task fragments that the task fragment depends on and the available output data markers of the upstream task fragments.

[0027] Each task fragment in the task fragment list generated in step S124 is treated as a node in a directed graph, with the node identifier identified by the fragment type of the task fragment. Each task fragment in the task fragment list is traversed, and its fragment content data is analyzed to determine if it references output data fields from other task fragments. The layout text string output by the copywriting fragment is the input source for overlaying text on image materials in the image processing fragment; therefore, a directed edge is created between the copywriting fragment node and the image processing fragment node, pointing from the copywriting fragment node to the image processing fragment node. The final selling price calculated by the pricing strategy fragment is the input parameter for the inventory configuration fragment when calculating inventory reservation; therefore, a directed edge is created between the pricing strategy fragment node and the inventory configuration fragment node, pointing from the pricing strategy fragment node to the inventory configuration fragment node. All nodes and directed edges constitute the initial structure graph of the collaborative task. Precondition data items are set for each task fragment node in the initial structure graph of the collaborative task. The precondition data items are a list, and each element in the list contains the identifier of the dependent upstream task fragment, the completion status flag requirement value, and the output data availability flag requirement value. The completion status flag requires a value of the enumerated value SUCCESS, and the output data availability flag requires a value of the boolean value True. If a task fragment node has no incoming edges, its precondition data item list is empty.

[0028] Step S126: Set execution boundary parameters for each task fragment in the initial structure diagram of the collaborative task. The execution boundary parameters include the maximum waiting time of the task fragment and the number of consecutive retries allowed for the task fragment.

[0029] An execution boundary parameter dictionary is set for each task fragment node in the initial structure diagram of the collaborative task. The execution boundary parameter dictionary contains two key-value pairs: the key, the maximum waiting time, is set to a positive integer, representing the maximum number of milliseconds the task fragment can wait from entering the distribution queue to starting execution; the key, the allowed number of consecutive retries, is set to a positive integer, representing the maximum number of consecutive retries the task fragment can make after failing due to an abnormal reason. The maximum waiting time and the allowed number of consecutive retries for each task fragment are read from a preset execution boundary parameter template table based on the fragment type label. The maximum waiting time setting for the image processing fragment is greater than that for the copywriting and layout fragment, while the maximum waiting time settings for the pricing strategy fragment and the inventory configuration fragment are the same and less than that for the image processing fragment.

[0030] Step S127: Set output verification rules for each task fragment in the initial structure diagram of the collaborative task. The output verification rules include the data format requirements and data content matching templates for the output of the task fragment.

[0031] For each task fragment node in the initial structure diagram of the collaborative task, set a list of output validation rules. Each validation rule in the output validation rule list is a JSON object containing three keys: the key is the validation field name, specifying the name of the output data field to be validated; the key is the data format requirement, specifying the data type constraint and length constraint of the field; and the key is the data content matching template, specifying the regular expression pattern or enumeration list that the value of the field should match. For example, the output validation rule for the copywriting and layout fragment specifies that the data format requirement for the output field "layout text string" is string type and the length is between the preset minimum and maximum length, and the data content matching template is a regular expression pattern containing HTML tags. The output validation rule for the image processing fragment specifies that the data format requirement for the output field "processed image Uniform Resource Locator" is a valid URL string. The output validation rule for the pricing strategy fragment specifies that the data format requirement for the output field "final selling price" is a floating-point number with two decimal places, and the data content matching template is a numerical range greater than 0. The output validation rules for inventory configuration fragments specify that the data format of the output field "Inventory Reserve Quantity" must be an integer type, and the data content matching template must be a numerical range greater than or equal to the starting value of the inventory reserve and less than or equal to the ending value of the inventory reserve.

[0032] Step S128: Encapsulate all task fragments in the initial structure diagram of the collaborative task, which carries the preconditions, execution boundary parameters and output verification rules, into state nodes to generate an initial state node for the collaborative task. Then, send the initial state node of the collaborative task to the task scheduling agent, which writes the initial state node of the collaborative task into the state storage area of ​​the agent's collaborative network.

[0033] The precondition list, execution boundary parameter dictionary, and output verification rule list associated with each task fragment node in the initial collaborative task structure graph are added as additional attributes to that node. The complete set of nodes and edges in the initial collaborative task structure graph are serialized into a JSON-formatted state node data packet. The top-level JSON object of the state node data packet contains node list keys and edge list keys. Each node object in the node list contains fragment identifier keys, fragment type marker keys, fragment content data keys, precondition keys, execution boundary parameter keys, and output verification rule keys. A task constraint set key and a task completion benchmark set key are added to the state node data packet. The task constraint set contains a list of applicable channel platforms for the activity and the maximum total budget for the activity. The task completion benchmark set contains all fragments with a SUCCESS status and all fragment output data verified by the output verification rules. After receiving the state node data packet, the task scheduling agent stores the state node data packet as a binary large object in the distributed key-value state storage area of ​​the agent's collaborative network, using a unique business process identifier as the key and the serialized string of the state node data packet as the value.

[0034] Step S130: The task scheduling agent performs a status reading operation on the initial state node of the collaborative task, generates a task distribution path sequence and a task status feedback channel identifier for the initial state node of the collaborative task, and sends the task data fragments extracted from the initial state node of the collaborative task along the task distribution path sequence to multiple dedicated processing agents corresponding to the task type.

[0035] After the initial state node of the collaborative task is written into the agent collaborative network, the task scheduling agent reads the node content, constructs the task distribution path sequence and establishes a feedback channel, and allocates each task fragment to a dedicated processing agent with corresponding processing capabilities.

[0036] Step S131: The task scheduling agent decomposes the structure of the initial state node of the collaborative task, extracts all task fragments contained in the initial state node of the collaborative task, as well as the fragment type label, preconditions, execution boundary parameters and output verification rules carried by each task fragment.

[0037] The task scheduling agent reads the state node data packet string of the initial state node of the collaborative task from the state storage area using the business process identifier as the key. It then calls a JSON parser to deserialize the string into a node graph data structure in memory. The agent iterates through the array corresponding to the node list keys in the node graph data structure. For each node object in the array, it extracts the string value corresponding to the fragment identifier key as the fragment identifier, the string value corresponding to the fragment type marker key as the fragment type marker, the array corresponding to the precondition key as the precondition list, the object corresponding to the execution boundary parameter key as the execution boundary parameter dictionary, and the array corresponding to the output verification rule key as the output verification rule list. All extracted task fragment information is organized into a fragment information mapping table. The key of the mapping table is the fragment identifier, and the value is a structure containing the fragment type marker, the precondition list, the execution boundary parameter dictionary, and the output verification rule list.

[0038] Step S132: Based on the fragment type tag carried by each task fragment, search for a dedicated processing agent with corresponding processing capabilities from the preset dedicated agent registry, generate a fragment processing binding relationship, and describe the processing correspondence between the task fragment and the dedicated processing agent.

[0039] The dedicated agent registry is implemented using a distributed, consistent key-value store system. The registry keys are fragment type marker strings, and the value fields are the application programming interface (API) endpoint URLs and a list of agent identifiers for the dedicated agent handling that fragment type. The task scheduling agent uses the fragment type marker for each task fragment as the key and performs an exact key lookup operation in the dedicated agent registry to retrieve the corresponding list of dedicated agents. A round-robin load balancing strategy is used to select a dedicated agent from the list as the executor for that task fragment. A triple is formed by combining the fragment identifier, the identifier of the selected dedicated agent, and the API endpoint URL, creating a fragment processing binding record. All fragment processing binding records form a fragment processing binding list.

[0040] Step S133: Construct a global prerequisite dependency graph based on the prerequisites carried by each task fragment. The nodes of the global prerequisite dependency graph are task fragments, and the directed edges of the global prerequisite dependency graph indicate that the starting task fragment is a prerequisite dependency of the ending task fragment.

[0041] Create an empty directed graph data structure as the global prerequisite dependency graph. Iterate through each task fragment in the fragment information mapping table, creating a corresponding node for each task fragment in the global prerequisite dependency graph. Iterate through the prerequisite condition list for each task fragment again; each element in the prerequisite condition list contains a field for the identifier of the dependent upstream task fragment. For each dependent upstream task fragment identifier in the prerequisite condition list, add a directed edge from the node corresponding to that upstream task fragment identifier to the current task fragment node in the global prerequisite dependency graph. The starting point of the directed edge is the dependent upstream task fragment node, and the ending point is the current task fragment node. The directed edge has the following attributes: the completion status flag must be SUCCESS, and the output data availability flag must be True.

[0042] Step S134: Find the set of starting task fragments that do not have any predecessor edges from the global predecessor dependency graph, and mark the starting task fragments in the set of starting task fragments as immediately distributable.

[0043] In the global prerequisite dependency graph, for each task fragment node, calculate its in-degree, which is equal to the number of directed edges ending at that node. Collect all task fragment nodes with an in-degree of 0 into the initial task fragment set. For each initial task fragment node in the initial task fragment set, set its execution status flag field to an immediately dispatchable state enumeration value.

[0044] Step S135: Find the set of successor task fragments with predecessor edges from the global predecessor dependency graph, and mark the successor task fragments in the set of successor task fragments as waiting to be triggered. The waiting to be triggered state means that it can only be dispatched after the execution completion event of the predecessor task fragment is triggered.

[0045] In the global predecessor dependency graph, all task fragment nodes with an in-degree greater than 0 are collected into the successor task fragment set. For each successor task fragment node in the successor task fragment set, its execution status flag field is set to the waiting-to-trigger state enumeration value, and the node's attached attributes store a list of predecessor task fragment identifiers that the successor task fragment depends on. The list contains the identifiers of the starting nodes of all incoming edges of the successor task fragment node in the global predecessor dependency graph.

[0046] Step S136: Based on the fragment processing binding relationship, assign task fragments that can be immediately distributed to the corresponding dedicated processing agents to generate a first-level distribution task set.

[0047] For each task fragment in the initial task fragment set that is in an immediately dispatchable state, search the fragment processing binding relationship list for a binding relationship record that matches the fragment identifier, and obtain the application interface endpoint URL of the dedicated processing agent in that record. Serialize the fragment content data, execution boundary parameter dictionary, and output verification rule list of the task fragment into a task execution request message body, and use the application interface endpoint URL of the dedicated processing agent as the message delivery target to generate a first-level dispatch task record. All first-level dispatch task records constitute the first-level dispatch task set.

[0048] Step S137: Based on the fragment processing binding relationship and the global pre-dependency graph, sort the task fragments in the waiting trigger state according to the dependency level from shallow to deep to generate a multi-level serial distribution sequence. Each level of the multi-level serial distribution sequence corresponds to a dependency level.

[0049] The global dependency graph is topologically divided. The first dependency level contains the initial set of task fragments. The second dependency level contains all task fragments that directly depend on the task fragments in the first dependency level and whose entire predecessor dependency is contained in the preceding level. This division is iteratively continued until all task fragments are assigned to a dependency level. A higher dependency level value indicates a later execution order for the task fragment. For each task fragment in a waiting-to-trigger state within a dependency level, the corresponding dedicated processing agent is retrieved from the fragment processing binding relationship list, generating a distribution sequence for that dependency level. Each record in the distribution sequence contains a task fragment identifier, a target dedicated processing agent identifier, the target dedicated processing agent's application programming interface endpoint URL, and a trigger condition. The trigger condition is a list of events waiting for the predecessor task fragment to complete execution. The distribution sequences of each dependency level are arranged in ascending order of dependency level to generate a multi-level serial distribution sequence.

[0050] Step S138: Concatenate the first-level task distribution set and the multi-level serial distribution sequence according to the distribution order to generate a task distribution path sequence. Each path node in the task distribution path sequence contains a task fragment identifier, a target dedicated agent identifier, and a trigger condition.

[0051] Create an empty ordered list as the task distribution path sequence. First, append all distribution task records from the first-level distribution task set to the task distribution path sequence, setting the trigger condition field of the first-level distribution task records to "immediately trigger". Then, append the distribution sequence with dependency level 2 from the multi-level serial distribution sequence to the task distribution path sequence, and then append the distribution sequences with dependency levels 3, 4, and up to the highest dependency level in sequence. During appending, each distribution sequence record is converted into a path node object, which contains a task fragment identifier key, a target-specific agent identifier key, and a trigger condition key. The value of the trigger condition key is a condition object, which contains a trigger type field and a predecessor fragment identifier list field. The trigger type field is set to "wait for predecessor to complete", and the predecessor fragment identifier list field is an array consisting of the starting node identifiers of all incoming edges of this task fragment in the global predecessor dependency graph.

[0052] Step S139: Create a message listening port in the agent cooperative network through the task scheduling agent, and assign a task status feedback channel identifier to the message listening port. Bind the task status feedback channel identifier to all path nodes in the task distribution path sequence, so that the status feedback generated by the task fragments executed along the task distribution path sequence is all converged to the listening channel indicated by the task status feedback channel identifier.

[0053] The task scheduling agent invokes the temporary queue creation API of the message queue middleware to create an exclusive temporary message queue. The message queue middleware returns a queue name string as the task status feedback channel identifier. The task scheduling agent starts an asynchronous message consumer thread to continuously and blockingly listen to the temporary message queue. The callback function of the consumer thread is bound to the task execution feedback message handling function. It iterates through each path node in the task distribution path sequence, adding a feedback channel identifier key-value pair to the additional properties of the path node object. The key is the feedback channel identifier, and the value is the queue name string of the temporary message queue. When each dedicated processing agent finishes executing a task fragment, it sends a task execution feedback message to the queue name. The task scheduling agent extracts the task fragment identifier and fragment content data for each path node from the task distribution path sequence, encapsulates the task fragment identifier and fragment content data into a task execution request message, and sends the task execution request message via an HTTP POST request to the API endpoint URL of the dedicated processing agent indicated by the target dedicated agent identifier in the corresponding path node. The HTTP POST request message body carries the task fragment identifier field, fragment content data field, execution boundary parameter field, output verification rule field, and feedback channel identifier field.

[0054] Step S140: Receive task execution feedback messages from multiple dedicated processing agents on the channel indicated by the task status feedback channel identifier. The task scheduling agent parses the task status flag, task output data packet, and task exception reason code from the task execution feedback message. The task status flag is then compared with the corresponding benchmark entry in the task completion benchmark set to generate a state transition trigger instruction.

[0055] The task scheduling agent continuously monitors the feedback channel and performs structured analysis and deviation analysis on the execution results returned by each dedicated processing agent, providing a basis for decision-making in subsequent state transitions.

[0056] Step S141: The task scheduling agent continuously listens to the message channel indicated by the task status feedback channel identifier and receives the raw feedback data stream pushed by multiple dedicated processing agents after their respective task fragments have been executed. The raw feedback data stream contains the sender agent identifier and message body data.

[0057] The asynchronous message consumer thread of the task scheduling agent performs a blocking dequeue operation on a temporary message queue. When a message arrives in the queue, the consumer thread obtains the raw byte stream of the message. The message header contains a sender agent identifier field, and the message body contains a message body data string encoded in JSON format. The consumer thread extracts the value of the sender agent identifier field and the message body data string into a memory variable.

[0058] Step S142: Retrieve the corresponding task fragment identifier from the task distribution path sequence based on the sender agent identifier, associate the task fragment identifier with the message body data in the original feedback data stream, generate message body data with task fragment identifier, decompose the message structure of the message body data with task fragment identifier, extract the task execution result marker field in the header area of ​​the message body data, determine the task execution result type based on the value of the task execution result marker field, the task execution result type includes normal completion type and abnormal interruption type.

[0059] Using the sender agent identifier as the query key, the target agent identifier field of each path node in the task distribution path sequence is traversed to find the path node whose target agent identifier matches the sender agent identifier. The task fragment identifier of that path node is then extracted. This task fragment identifier is written as an additional key into the message body data JSON object, generating message body data with task fragment identifiers. The task execution result flag field is read from the top-level JSON object of the message body data with task fragment identifiers. If the value of the task execution result flag field is SUCCESS, the task execution result type is normal completion. If the value of the task execution result flag field is FAILURE, the task execution result type is abnormal interruption.

[0060] Step S143: When the task execution result type is normal completion, extract the task output data packet from the message payload area of ​​the message body data with task fragment identifier, and bind and store the task output data packet with the corresponding task fragment identifier; when the task execution result type is abnormal interruption, extract the task abnormality details data segment from the message payload area of ​​the message body data with task fragment identifier, and parse the task abnormality reason code from the task abnormality details data segment. The task abnormality reason code includes data format conflict code, external interface call failure code, and execution timeout overflow code; when the task execution result type is abnormal interruption, mark the task fragment corresponding to the task abnormality reason code as a faulty fragment, locate the downstream dependent task fragment set of the faulty fragment from the task distribution path sequence, and set a suspended execution mark for all task fragments in the downstream dependent task fragment set.

[0061] When the task execution result type is normal completion, the value of the task output data packet (key) is read from the message body data JSON object. This value is a nested JSON object storing the business data generated by the task fragment execution. The task fragment identifier is used as the key, and the task output data packet is used as the value, stored in the output data cache mapping table in the task scheduling agent's memory. When the task execution result type is abnormal interruption, the value of the task abnormality details data segment (key) is read from the message body data JSON object. This value is a JSON object, from which the string value of the task abnormality reason code (key) is read. The enumerated values ​​of the task abnormality reason codes include FMT (data format conflict), API (external interface call failure), and TMO (execution timeout overflow). The fault flag of the task fragment that generated the task abnormality reason code in memory is set to True. Then, all directed edges originating from the faulty fragment node in the global pre-dependency graph are traversed, and the task fragment identifiers corresponding to the endpoint nodes of each directed edge are collected to form a downstream dependent task fragment set. For each task fragment in the downstream dependent task fragment set, a suspended execution flag is written to the status field of the corresponding path node in the task distribution path sequence.

[0062] Step S144: Input the task status flag, task output data packet and task exception reason code into the deviation analysis module of the task scheduling agent. The deviation analysis module compares the task status flag with the output verification rules in the initial state node of the collaborative task item by item to generate deviation analysis results. The deviation analysis results include deviation fragment identifiers and deviation field descriptions.

[0063] The task status flag field value is extracted from the message body data. The task status flag and the task output data packet or task exception reason code extracted in step S143 are used as input to the deviation analysis module. The deviation analysis module extracts the output verification rule list corresponding to the task fragment that generated feedback from the initial state node of the collaborative task. If the task status flag is SUCCESS, the deviation analysis module traverses each verification rule in the output verification rule list and performs data format verification and data content matching verification on the field value with the verification field name as the key in the task output data packet. If all verification rules pass the verification, the deviation field description in the deviation analysis result is an empty list. If a verification rule fails, the name of the failed verification field and the reason for failure are appended to the deviation field description list, and the task fragment identifier is recorded as the deviation fragment identifier. If the task status flag is FAILURE, the deviation fragment identifier is set to the task fragment identifier that generated the task exception reason code, and the deviation field description is set to a description list containing the task exception reason code string.

[0064] Step S145: Combine and encapsulate the deviation analysis results, task output data packets, and task exception cause codes to generate state transition trigger instructions.

[0065] Create a state transition trigger instruction JSON object. This object contains a deviation fragment identifier key, a deviation field description key, a task output data package key, and a task exception reason code key. The deviation fragment identifier key is set to the deviation fragment identifier string from the deviation analysis results. The deviation field description key is set to the list of deviation field descriptions from the deviation analysis results. The task output data package key is set to the task output data package cached in step S143 or an empty object. The task exception reason code key is set to the task exception reason code string or an empty string. The state transition trigger instruction JSON object is serialized to a JSON string and returned.

[0066] Step S150: Based on the state transition trigger instruction, select the corresponding state transition path in the agent cooperative network, drive the task scheduling agent to update the initial state node of the cooperative task to the subsequent state node of the cooperative task along the state transition path, and rearrange the task distribution path sequence based on the task output data packet and the task exception reason code under the subsequent state node of the cooperative task to generate an updated task distribution path sequence, and use the task output data packet as the task context constraint when multiple dedicated processing agents execute the task again.

[0067] After generating the state transition trigger instruction, the task scheduling agent selects an appropriate correction path based on the instruction content, creates a successor state node and updates the task distribution path, and passes the completed task output as context to the subsequent execution process.

[0068] Step S151: Extract the deviation fragment identifier, deviation field description, task exception reason code, and task output data packet from the state transition trigger instruction.

[0069] The task scheduling agent reads the string value of the deviation fragment identifier key, the array value of the deviation field description key, the string value of the task exception reason code key, and the JSON object value of the task output data packet key from the state transition trigger instruction JSON object, and stores the above four variables in memory.

[0070] Step S152: Locate the task fragment to be corrected in the initial state node of the collaborative task based on the deviation fragment identifier, associate the task fragment to be corrected with the deviation field description, and generate a tuple of the fragment description to be corrected.

[0071] Using the deviation fragment identifier string as the key, search for the node object whose fragment identifier key matches the key in the array corresponding to the node list of the initial state node of the collaborative task. Mark this node object as a fragment to be corrected. Create a tuple containing three elements: the first element is the fragment identifier of the fragment to be corrected, the second element is the array of deviation field descriptions, and the third element is the fragment type marker string of the fragment to be corrected. This tuple is the fragment description tuple to be corrected.

[0072] Step S153: Query the preset state transition mapping table according to the task exception reason code. The state transition mapping table stores the mapping relationship between exception reason codes and state transition paths. Determine the candidate state transition path set based on the query results. The candidate state transition path set includes task fragment replacement paths and task fragment parameter adjustment paths.

[0073] The state transition map is stored in the task scheduling agent's memory as a hash table. The keys of the map are strings representing the enumerated values ​​of task exception reason codes, and the values ​​are lists of state transition paths. The map is queried using the task exception reason code string extracted in step S151 as the key to obtain a set of candidate state transition paths. Each state transition path in the candidate state transition path set is a JSON object containing a path type key and a path operation list key. The path type key's value includes REPLACE (representing a task fragment replacement path) and ADJUST (representing a task fragment parameter adjustment path). The path operation list key's value is a JSON array, where each element describes a specific node attribute modification operation.

[0074] Step S154: Calculate the path selection weight for each candidate state transition path in the candidate state transition path set. The path selection weight is determined by using the deviation type described in the deviation field of the fragment description tuple to be corrected, and the historical correction success rate of the candidate state transition path as the matching dimension and the statistical dimension, respectively.

[0075] For each candidate state transition path in the candidate state transition path set, a matching dimension score is calculated. The matching dimension score is the sum of the text similarity scores between the description string of each deviation field in the deviation field description array and the description of each operation in the path operation list of the candidate state transition path. The text similarity score is calculated using a pre-trained word vector model to calculate the cosine similarity between two texts. The statistical dimension score is read from a historical correction success rate database, which stores historical correction success rates using a combination of anomaly reason code and path type as keys. Path selection weight = α × matching dimension score + β × statistical dimension score, where α and β are preset fusion coefficients, and α + β = 1.

[0076] Step S155: Select the candidate state transition path with the highest path selection weight as the target state transition path. The target state transition path includes the target state node type and state node attribute modification operations.

[0077] Compare the path selection weights of all candidate state transition paths in the candidate state transition path set, and select the candidate state transition path with the highest path selection weight as the target state transition path. Read the path type key from the JSON object of the target state transition path to obtain the target state node type, and read the path operation list key to obtain the state node attribute modification operation list.

[0078] Step S156: Create a blank cooperative task successor state node in the agent cooperative network that is consistent with the target state node type, and copy the normal task fragments that are not marked as task fragments to be corrected in the initial state node of the cooperative task to the blank cooperative task successor state node as is.

[0079] The task scheduling agent creates a new empty node graph data structure in memory as a blank successor state node for the cooperative task. It iterates through the array corresponding to the node list keys of the initial state node of the cooperative task. For each node object, if its fragment identifier is not equal to the deviation fragment identifier, a deep copy operation is performed on the node object, and the resulting node object is appended to the array corresponding to the node list keys of the blank successor state node. Simultaneously, a deep copy of the array corresponding to the edge list keys of the initial state node of the cooperative task is performed and appended to the blank successor state node.

[0080] Step S157: Execute the state node attribute modification operation contained in the target state transition path of the task fragment to be corrected. The state node attribute modification operation includes modifying the preconditions of the task fragment to be corrected, modifying the execution boundary parameters of the task fragment to be corrected, and modifying the output verification rules of the task fragment to be corrected. Write the modified task fragment into the blank cooperative task successor state node.

[0081] Iterate through the list of state node attribute modification operations along the target state transition path. For each operation JSON object in the list, read the value of the operation type key: if it modifies the preconditions, read the new precondition array value and replace the value of the precondition key of the task fragment node object to be corrected with the new precondition array; if it modifies the execution boundary parameters, read the new execution boundary parameter JSON object value and replace the value of the execution boundary parameter key of the task fragment node object to be corrected with the new execution boundary parameter JSON object; if it modifies the output verification rules, read the new output verification rule array value and replace the value of the output verification rule key of the task fragment node object to be corrected with the new output verification rule array. After completing all modification operations, append the modified task fragment node object to be corrected to the array corresponding to the node list key of the blank collaborative task's successor state node.

[0082] Step S158: Use the task output data packet to fill the input data slots of the downstream task fragments that have input-output connection with the task fragment to be corrected in the successor state node of the collaborative task, mark the state of the initial state node of the collaborative task in the agent collaborative network as the transferred state, and activate the successor state node of the collaborative task as the currently active state node.

[0083] Traverse the array of edge list keys corresponding to the successor state nodes of the blank collaborative task, find the directed edges whose starting node is the task fragment node to be corrected, and collect the endpoint node identifiers of these directed edges. These endpoint nodes are the downstream task fragments. For each downstream task fragment node, add input data slot key-value pairs to its fragment content data JSON object. The key is the output field name of the task output data packet, and the value is extracted from the value of the corresponding key in the task output data packet JSON object. After completing the input data filling, the task scheduling agent sends an update operation to the state storage area, updates the state flag field corresponding to the initial state node of the collaborative task to the transferred state string, serializes the blank collaborative task successor state node into a JSON string and writes it to the state storage area, and sets its state flag field to the currently active state string.

[0084] Step S160: Under the successor state node of the collaborative task, rearrange the task distribution path sequence based on the task output data packet and the task exception reason code to generate an updated task distribution path sequence, and use the task output data packet as the task context constraint when multiple dedicated processing agents execute the task again.

[0085] Step S161: Extract the current preconditions and current execution boundary parameters of all task fragments from the successor state nodes of the collaborative task, and reconstruct the global precondition dependency graph corresponding to the successor state nodes of the collaborative task based on the current preconditions.

[0086] Iterate through the array corresponding to the node list keys of the successor state nodes of the collaborative task, and extract the value of the fragment identifier key and the value of the precondition key for each node object. Construct a new global precondition dependency graph using the same method as in step S133.

[0087] Step S162: Map the task exception cause code to a task fragment avoidance strategy. The task fragment avoidance strategy is used to isolate the downstream task fragments of the faulty fragment that generated the task exception cause code in the global pre-dependency graph and temporarily remove the downstream task fragments from the original dependency path.

[0088] Based on the value of the task exception reason code, the corresponding task fragment avoidance strategy type is queried from the fragment avoidance strategy table. If the task fragment avoidance strategy type is path isolation, all directed edges originating from the faulty fragment node are found in the new global prerequisite dependency graph. The endpoint nodes of these directed edges are removed from the original dependency hierarchy, and the entries in the prerequisite condition list of these downstream task fragment nodes that depend on the upstream task fragment identifier are deleted.

[0089] Step S163: Use the task output data package to replace the input data slots of the task fragments in the waiting-to-be-triggered state in the global prerequisite dependency graph, and mark the prerequisite conditions of the replaced task fragments as satisfied.

[0090] Iterate through all task fragment nodes in the new global prerequisite dependency graph that are in a waiting-to-be-triggered state. If the fragment content data JSON object of a task fragment node contains input data slot key-value pairs, and the corresponding key exists in the task output data packet JSON object, then update the value of the input data slot key-value pair to the value of the corresponding key in the task output data packet JSON object, and set the prerequisite condition completion flag of the task fragment node to True.

[0091] Step S164: Perform topological sorting on the global pre-dependency graph after path isolation and data replacement to generate a new multi-level task execution sequence. In the new multi-level task execution sequence, task fragments carrying task fragment avoidance strategies are redistributed to standby dedicated processing agents. The standby dedicated processing agents have the same fragment type marking and processing capabilities as the original dedicated processing agents.

[0092] The new global prerequisite dependency graph modified in steps S162 and S163 is topologically sorted to obtain a new dependency hierarchy. In the new multi-level task execution sequence, for task fragments marked as needing reallocation, a backup dedicated processing agent with the same fragment type marking processing capability as the original dedicated processing agent but a different agent identifier is selected from the dedicated agent registry. The value of the target dedicated agent identifier key of the task fragment is updated to the identifier of the backup dedicated processing agent.

[0093] Step S165: Maintain the binding relationship between the unreassigned task fragments and the original dedicated processing agent, only update the triggering conditions of the unreassigned task fragments in the new multi-level task execution sequence, write the updated binding relationship and the updated triggering conditions into the task distribution path sequence, and generate the updated task distribution path sequence.

[0094] For task fragments in the new multi-level task execution sequence that have not been reassigned, their dedicated processing agent binding relationships in the original fragment processing binding relationships remain unchanged. The trigger conditions for each task fragment are updated according to the new dependency hierarchy order, and the list of preceding fragment identifiers in the trigger conditions is updated to include all incoming edge start node identifiers of the task fragment node in the new global preceding dependency graph. Each task fragment in the updated multi-level task execution sequence is encapsulated as a path node object, containing a task fragment identifier key, a target dedicated agent identifier key, a trigger condition key, and a feedback channel identifier key. All path node objects are arranged in execution order to form the updated task distribution path sequence.

[0095] Step S166: Rebind each path node in the updated task distribution path sequence with the task status feedback channel identifier, so that the status feedback generated during the execution of the updated task distribution path sequence continues to converge to the listening channel indicated by the task status feedback channel identifier.

[0096] Iterate through each path node object in the updated task distribution path sequence and set its feedback channel identifier key to the queue name string of the temporary message queue generated in step S139. At this point, the updated task distribution path sequence is complete. The task scheduling agent sends the task fragments corresponding to each path node sequentially to the corresponding dedicated processing agent for execution, following the order of the updated task distribution path sequence. The task output data packet serves as a task context constraint and is carried in the task context constraint field of the task execution request message sent to the dedicated processing agent corresponding to the downstream task fragment. The downstream dedicated processing agent must use the task context constraint as one of the input parameters in the decision-making of the processing logic when processing its own task fragment.

[0097] Step S210: After sending the updated task distribution path sequence to the corresponding dedicated processing agent, continuously receive secondary execution feedback messages from multiple dedicated processing agents on the channel indicated by the task status feedback channel identifier. The secondary execution feedback messages include secondary task status flags, secondary task output data packets, and secondary task exception reason codes.

[0098] The task scheduling agent continues to listen to the temporary message queue, receiving execution feedback messages from each dedicated processing agent regarding the task fragments allocated in the updated task distribution path sequence. The message body JSON object structure of the secondary execution feedback message includes a secondary task status flag field, a secondary task output data packet field, and a secondary task exception reason code field.

[0099] Step S211: Perform a secondary deviation comparison between the secondary task status marker and the output verification rules of the corresponding task fragment in the subsequent status node of the collaborative task. If the secondary deviation comparison result indicates that there is still a task fragment execution failure, extract the secondary abnormal features from the secondary task abnormal reason code, and select a deep error correction strategy from the preset deep error correction strategy library based on the secondary abnormal features. The deep error correction strategy includes the dedicated processing agent capability reconfiguration operation and the task fragment fine-grained splitting operation.

[0100] For task fragments marked as FAILURE in the secondary execution feedback message, the output verification rule list corresponding to the task fragment is extracted from the subsequent status node of the collaborative task, and the same deviation comparison operation as in step S144 is performed. If the deviation comparison result indicates that there are still task fragments that have failed to execute, the secondary task exception reason code string is used as the query key to retrieve the corresponding deep error correction policy JSON object from the deep error correction policy library. The deep error correction policy JSON object contains capability reconfiguration flags and fine-grained splitting flags.

[0101] Step S212: Adjust the internal processing logic parameters of the dedicated processing agent that generates the secondary task exception reason code according to the dedicated processing agent capability reconfiguration operation, and synchronize the adjusted internal processing logic parameters to the corresponding dedicated processing agent.

[0102] If the capability reconfiguration flag in the deep error correction policy JSON object is True, the task scheduling agent sends an internal processing logic parameter update instruction to the configuration management endpoint of the dedicated processing agent that generated the secondary task exception reason code via an HTTPPATCH request. The message body of the update instruction contains the new processing timeout threshold parameter and the new retry policy parameter. After receiving the update instruction, the dedicated processing agent hot-updates its internal parameters and returns an acknowledgment response.

[0103] Step S213: Based on the fine-grained splitting operation of task fragments, split the failed task fragments into multiple sub-task fragments. Each sub-task fragment carries independent sub-preconditions and sub-output verification rules. Insert multiple sub-task fragments into the subsequent state node of the collaborative task to generate a deep error correction state node for the collaborative task.

[0104] If the fine-grained splitting flag in the deep error correction strategy JSON object is True, the fragment content data of the failed task fragments will be further split. The splitting strategy selects the corresponding splitting template based on the fragment type label of the task fragment. The splitting template defines how to split a complex business operation in the fragment content data into multiple independent atomic operations, each atomic operation corresponding to a subtask fragment. An independent sub-precondition list, sub-execution boundary parameter dictionary, and sub-output verification rule list are generated for each subtask fragment. The original failed task fragment node is deleted from the collaborative task successor state node, and each subtask fragment node is inserted into the position of the original task fragment node in the global precondition dependency graph, and the directed edge connection relationship between the subtask fragment nodes is re-established. The modified collaborative task successor state node is saved as a collaborative task deep error correction state node and written to the state storage area.

[0105] Step S214: Reconstruct the global prerequisite dependency graph under the deep error correction state node of the collaborative task, re-sort all task fragments and sub-task fragments in the deep error correction state node of the collaborative task, generate a deep error correction task distribution path sequence, and send the deep error correction task distribution path sequence for execution.

[0106] Perform the same processing steps as steps S161 to S166 on the deep error correction status nodes of the collaborative task to generate a deep error correction task distribution path sequence. Then, sequentially distribute each path node in the deep error correction task distribution path sequence to the corresponding dedicated processing agent for execution.

[0107] Step S310: In the agent cooperative network, record the state transition trajectory between the initial state node of the cooperative task, the subsequent state node of the cooperative task, and the deep error correction state node of the cooperative task. Store the state transition trajectory as a state transition log sequence. The state transition log sequence contains the trigger reason code and path selection result for each state transition.

[0108] Each time the task scheduling agent executes a state transition, it generates a state transition log record. The state transition log record JSON object contains a key for the state node identifier before the transition, a key for the state node identifier after the transition, a key for the trigger reason code, and a key for the path selection result. The value of the path selection result key is a JSON object containing the path type and path selection weight of the selected target state transition path. All state transition log records are appended to the state transition log sequence in ascending order of timestamps. The state transition log sequence is stored in the state storage area using the business process identifier as the key.

[0109] Step S311: Perform frequency statistics on the trigger reason codes in the state transition log sequence to generate an exception reason code frequency distribution. The exception reason code frequency distribution describes the frequency of various exception reason codes during the state transition process.

[0110] Iterate through each state transition log record in the state transition log sequence, extract the value of the trigger reason code key, and accumulate the occurrence count for each different trigger reason code value. After the statistics are completed, generate an exception reason code frequency distribution mapping table, where the key of the mapping table is the trigger reason code string, and the value is the frequency count value. Divide the frequency count value by the total number of records in the state transition log sequence to obtain the frequency percentage of each trigger reason code.

[0111] Step S312: Evaluate the path selection results in the state transition log sequence and generate a path correction success rate distribution. The path correction success rate distribution describes the success rate of various state transition paths in correcting task fragments.

[0112] For each state transition log record in the state transition log sequence, extract the path type string from the value of the path selection result key, and check whether a new state transition was triggered after the current state transition. If all task fragments of the state node are of the normal completion type at the end of the business process after the transition, mark the path selection as a successful correction. Count the number of successful corrections and the total number of corrections for each path type. The correction success rate is equal to the number of successful corrections divided by the total number of corrections. Generate a path correction success rate distribution mapping table.

[0113] Step S313: Feed back the frequency distribution of the anomaly cause code and the success rate distribution of the path correction to the maintenance interface of the state transition mapping table. After normalizing the frequency distribution of the anomaly cause code and the success rate distribution of the path correction, adjust the mapping weight between the anomaly cause code and the state transition path in the state transition mapping table according to the normalized feedback results.

[0114] The frequency proportions of each trigger reason code are normalized to the maximum value. The correction success rate of each path type is also normalized to the maximum value. For each anomaly reason code key in the state transition mapping table, the statistical dimension score parameter of the candidate state transition path is updated according to the normalized correction success rate corresponding to the path type. The order of each path in the candidate state transition path list is adjusted according to the normalized frequency proportion of the trigger reason code, with paths corresponding to anomaly reason codes with higher frequency proportions and higher correction success rates placed at the beginning of the list.

[0115] Step S410: Collect execution time data and computing resource consumption data of multiple dedicated processing agents when executing task fragments each time at the message listening port of the task scheduling agent, and generate a single execution overhead record.

[0116] Whenever the task scheduling agent receives a task execution feedback message, it additionally reads the execution duration key and computational resource consumption key from the message body's JSON object. The execution duration key is the number of milliseconds from when the task fragment begins processing to when it completes processing. The computational resource consumption key is a JSON object containing the number of CPU cores in seconds and the number of megabytes of memory in seconds consumed by this task execution. These values ​​are then associated with the task fragment identifier and the dedicated processing agent identifier to generate a JSON object recording the single execution cost.

[0117] Step S411: Aggregate the single execution overhead records according to the dedicated processing agent identifier and fragment type label to generate an agent fragment processing capability profile. The agent fragment processing capability profile includes the average processing time and average resource consumption of each dedicated processing agent for different fragment type labels.

[0118] All single-execution cost records are grouped according to a tuple of dedicated processing agent identifier and fragment type label. For all records within each group, the arithmetic mean of execution time is calculated as the average processing time, the arithmetic mean of CPU core counts in seconds is calculated as the average CPU consumption, and the arithmetic mean of memory memory counts in megabytes in seconds is calculated as the average memory consumption. The group key, average processing time, average CPU consumption, and average memory consumption are stored as an agent fragment processing capability profile record. All profile records form an agent fragment processing capability profile mapping table.

[0119] Step S412: When it is necessary to assign a dedicated processing agent to task fragments in the initial state node or subsequent state node of a collaborative task, query the fragment processing capability profile of the agent and select dedicated processing agents with an average processing time less than the processing time threshold as candidate allocation objects.

[0120] During the fragment processing binding relationship generation in step S132, after obtaining the list of dedicated processing agents from the dedicated agent registry, for each dedicated processing agent in the list, the agent fragment processing capability profile mapping table is queried using the dedicated processing agent identifier and the fragment type tag of the current task fragment as the binary key. If the average processing time found is less than the preset processing time threshold, the dedicated processing agent is added to the candidate allocation object list.

[0121] Step S413: Among the candidate allocation objects, select the dedicated processing agent whose average resource consumption is less than the resource consumption threshold as the target task execution agent, and allocate the task fragment to the target task execution agent.

[0122] Iterate through the candidate allocation object list, and for each candidate allocation object, query its average CPU consumption and average memory consumption in the agent fragmentation processing capability profile mapping table. If the average CPU consumption is less than a preset CPU consumption threshold and the average memory consumption is less than a preset memory consumption threshold, then mark the candidate allocation object as qualified. Select the dedicated processing agent with the shortest average processing time from all qualified candidate allocation objects as the target task execution agent. If there is no qualified dedicated processing agent in the candidate allocation object list, select the dedicated processing agent with the shortest average processing time as the target task execution agent. Set the dedicated processing agent identifier in the fragmentation processing binding relationship to the identifier of the target task execution agent.

[0123] For example, step S510: Extract all initial state nodes and all subsequent state nodes of the completed business process from the state storage area of ​​the intelligent agent collaborative network, group the extracted state node set according to the business process identifier, generate a state node evolution chain for a single business process, and record the transition order between state nodes in a single business process.

[0124] The task scheduling agent traverses all keys in the state storage area prefixed with a business process identifier, filtering out data packets with state nodes marked as completed. For each business process identifier, all state nodes under that business process identifier are sorted in ascending order by state transition timestamps, generating a state node evolution chain. Each element in the chain is a summary of a state node, including the state node identifier and state node type.

[0125] Step S511: Extract the state transition triggering instruction based on each state transition from the state node evolution chain, extract the deviation fragment identifier, deviation field description and task exception reason code carried in the state transition triggering instruction, arrange the deviation fragment identifier, deviation field description and task exception reason code according to the order of state transition occurrence, and generate the exception transmission path of a single business process.

[0126] Extract all state transition log records corresponding to the business process identifier from the state transition log sequence. For each state transition log record, read the values ​​of the deviation fragment identifier key, deviation field description key, and task exception reason code key from the corresponding state transition trigger instruction. Arrange these three values ​​in the order of the state transition occurrence to form an exception propagation path sequence, where each element in the exception propagation path sequence is a triplet.

[0127] Step S512: Extract the task distribution path sequence generated after each state transition from the state node evolution chain, extract the task fragment identifier and target dedicated intelligent agent identifier of the path node in the task distribution path sequence, arrange the task fragment identifier and target dedicated intelligent agent identifier according to the task distribution order, and generate the intelligent agent scheduling trajectory of a single business process.

[0128] Read the task distribution path sequence generated after each state transition under the business process identifier from the state storage area. For each task distribution path sequence, extract the value of the task fragment identifier key and the value of the target dedicated agent identifier key of each path node, and arrange them in the order of the path nodes to form an agent scheduling trajectory sequence. Each element in the agent scheduling trajectory sequence is a tuple.

[0129] Step S513: Align the sequence of task exception cause codes in the exception propagation path with the sequence of target dedicated intelligent agents in the intelligent agent scheduling trajectory position by position to generate a correspondence table between exception cause codes and scheduling intelligent agents. Take each pair of correspondences in the correspondence table as a collaborative behavior unit. Multiple collaborative behavior units form a collaborative behavior sample. Label the business process execution result type for each collaborative behavior unit in the collaborative behavior sample. The business process execution result type includes a single successful completion type and a successful completion type after state transition. Generate labeled collaborative behavior samples.

[0130] Using the timestamps of state transitions in the anomaly propagation path and agent scheduling trajectory as alignment benchmarks, the task anomaly reason codes and target-specific agent identifiers at the same time step are associated as a cooperative action unit. For each cooperative action unit, an execution result type label is marked based on whether the business process requires further state transitions after this state transition. If not, it is marked as successfully completed in one go; if so, it is marked as successfully completed after state transitions. All cooperative action units and their corresponding labels constitute a labeled cooperative action sample.

[0131] Step S514: Expand each anomaly propagation path in the labeled collaborative behavior samples generated by multiple different business processes, extract the task anomaly cause code sequence for each anomaly propagation path, perform common subsequence search on the task anomaly cause code sequences of different labeled collaborative behavior samples, and extract the common task anomaly cause code subsequence that appears repeatedly in different labeled collaborative behavior samples as the high-frequency anomaly propagation pattern.

[0132] A longest common subsequence algorithm based on suffix automata is adopted. Given a sequence of task exception cause codes for multiple exception propagation paths, the algorithm calculates the common subsequences among these sequences. A minimum common subsequence length threshold is set, and common subsequences exceeding this threshold are retained. The frequency of each common subsequence in different business process samples is counted, and common subsequences with frequencies exceeding a preset frequency threshold are marked as high-frequency exception propagation patterns.

[0133] Step S515: Extract the target dedicated agent identifier sequence from the agent scheduling trajectory corresponding to the high-frequency anomaly propagation mode, compare the differences between the task distribution path sequences before and after each state transition in the target dedicated agent identifier sequence, extract the set of path nodes that have changed in the task distribution path sequence at each state transition, and arrange the set of changed path nodes in the order of change to generate a preset path adjustment action sequence bound to the high-frequency anomaly propagation mode.

[0134] For each high-frequency anomaly propagation pattern, the corresponding agent scheduling trajectory is located in each business process sample where it occurs, and the task distribution path sequence before and after each state transition is identified. Set difference operations are used to calculate the differences between path nodes in the two task distribution path sequences, and newly added or modified path nodes are marked as changed. The attribute modification operation sequences of the changed path nodes are organized into a preset path adjustment action sequence. Each action in the preset path adjustment action sequence includes an operation type, an operation target fragment identifier, and operation parameters.

[0135] Step S516: Take the first task exception cause code of the common task exception cause code subsequence in the high-frequency exception propagation mode as the preset exception matching condition, encapsulate the preset exception matching condition and the preset path adjustment action sequence into a preset state transition template, and write the preset state transition template into the state transition mapping table. When the task scheduling agent parses the task exception cause code that matches the preset exception matching condition again, skip the path selection weight calculation step and directly call the preset path adjustment action sequence to perform the state transition.

[0136] The first task exception cause code in the common task exception cause code subsequence of the high-frequency exception propagation mode is used as the preset exception matching condition string. The preset exception matching condition is used as the key, and the preset path adjustment action sequence is encapsulated as a state transition path JSON object as the value. This key-value pair is written to the state transition mapping table. A priority flag is added to the state transition path JSON object and set to True. When querying the state transition mapping table in step S153, if there is a path with a priority flag of True in the candidate state transition path set, the path selection weight calculation in step S154 is skipped, and this path is directly selected as the target state transition path.

[0137] Step S610: After the task scheduling agent generates the task distribution path sequence, it traverses each pair of adjacent path nodes in the task distribution path sequence in turn. The path node that is upstream in the adjacent path node is called the upstream path node, and the path node that is downstream is called the downstream path node.

[0138] The task scheduling agent traverses the ordered list of path nodes in memory of the task distribution path sequence generated in step S138 or the updated task distribution path sequence generated in step S165. Starting from the starting index of the list, it sequentially selects a pair of path nodes with adjacent index positions, with the smaller index being the upstream path node and the larger index being the downstream path node.

[0139] Step S611: Extract the set of output data field names of upstream task fragments from the output verification rules of the task fragments corresponding to the upstream path nodes in the initial state node of the collaborative task, and extract the set of input data field names of downstream task fragments from the preconditions of the task fragments corresponding to the downstream path nodes in the initial state node of the collaborative task.

[0140] Using the task fragment identifier of the upstream path node as the key, the corresponding task fragment node object is found in the initial state node of the collaborative task. Its output validation rule list is traversed, and the validation field name string of each validation rule is extracted to form a set of upstream task fragment output data field names. Similarly, using the task fragment identifier of the downstream path node as the key, the corresponding task fragment node object is found in the initial state node of the collaborative task. Its precondition list is read, and the input data field name string of each precondition element is extracted to form a set of downstream task fragment required input data field names.

[0141] Step S612: Compare the set of field names of the output data of the upstream task fragments with the set of field names of the input data of the downstream task fragments, and identify the missing data field names that exist in the set of field names of the input data of the downstream task fragments but do not exist in the set of field names of the output data of the upstream task fragments.

[0142] For each field name in the downstream task fragment requirement input data field name set, search for it in the upstream task fragment output data field name set. If no exact match is found, add that field name to the missing data field name list.

[0143] Step S613: For each missing data field name, retrieve constraint data fields from the task constraint condition set carried by the initial state node of the collaborative task. If a matching constraint data field is found, extract the field value corresponding to the constraint data field and append the field value as filler data to the task data load of the downstream path node.

[0144] Iterate through each missing data field name in the list of missing data field names. Search the JSON object of the task constraint set for constraint data field keys whose keys are exactly the same as the missing data field name or semantically matched after synonym mapping. If a matching constraint data field key is found, read the value corresponding to that key and write the key-value pair into the fragment content data JSON object of the task fragment node object corresponding to the downstream path node as population input data.

[0145] Step S614: If no matching constraint data field is found in the task constraint set, return the original fragment content data of the task fragment corresponding to the upstream path node in the collaborative task initial state node, extract the additional output data field defined for the task fragment but not included in the output verification rules from the original fragment content data, and append the data field name and field value of the additional output data field to the upstream task fragment output data field name set and the corresponding task output data packet.

[0146] If a missing data field name in step S613 does not find a match in the task constraint set, then using that missing data field name as the key, a recursive search is performed in the original fragment content data JSON object of the task fragment node object corresponding to the upstream path node for a matching nested key. If the key is found in the original fragment content data, it is marked as an additional output data field, and the key-value pair is appended to the task output data packet returned by the upstream task fragment to the task scheduling agent after execution. At the same time, the key is added to the set of output data field names of the upstream task fragment.

[0147] Step S615: After completing the addition of constraint data fields or additional output data fields, re-execute the field-by-field name comparison between the upstream task fragment output data field name set and the downstream task fragment requirement input data field name set to confirm that the missing data field names have been eliminated. Then, synchronously write the updated upstream task fragment output data field name set and downstream task fragment requirement input data field name set into the corresponding path nodes in the task distribution path sequence.

[0148] Re-execute the comparison operation in step S612 to check if the list of missing data field names is empty. If it is empty, write the updated set of upstream task fragment output data field names as an additional attribute to the output data field name list of upstream path nodes, and write the updated set of downstream task fragment demand input data field names as an additional attribute to the demand input data field name list of downstream path nodes. If there are still missing data field names that have not been eliminated, record the missing data field name in the anomaly marker field of the task distribution path sequence and issue a data link breakage alarm to the task scheduling agent.

[0149] Step S710: After multiple dedicated processing agents start executing the task fragments allocated in the task distribution path sequence, the task scheduling agent sends a progress acquisition request to each dedicated processing agent according to a preset acquisition time interval, and receives the current execution progress snapshot returned by each dedicated processing agent. The current execution progress snapshot includes the number of task fragments that the dedicated processing agent has completed, the identifier of the task fragment being executed, and the number of task fragments to be executed.

[0150] The task scheduling agent starts a timer thread, which triggers the progress collection process according to a preset collection interval. Each time a timer is triggered, the task scheduling agent iterates through the application interface endpoint URLs of all dedicated processing agents assigned task fragments in the fragment processing binding relationship list, sending an HTTP GET request to each URL with the request path being the progress query endpoint of the dedicated processing agent. Upon receiving the progress collection request, the dedicated processing agent calculates the status of its internal task execution queue, constructs a current execution progress snapshot JSON object, and returns it. The current execution progress snapshot JSON object contains three key-value pairs: the key for the number of completed tasks is an integer, representing the total number of task fragments successfully executed by the dedicated processing agent in this business process; the key for the currently executing task identifier is a string or null value; if the dedicated processing agent currently has a task fragment being processed by an internal worker thread, the key's value is the fragment identifier string of that task fragment, otherwise it is null; and the key for the number of tasks waiting to be executed is an integer, representing the number of task fragments queued in the dedicated processing agent's internal task waiting queue.

[0151] Step S711: Add the number of completed task fragments and the number of task fragments to be executed for each dedicated processing agent to obtain the total number of allocated task fragments for that dedicated processing agent. Divide the number of completed task fragments by the total number of allocated task fragments to obtain the actual execution progress ratio of that dedicated processing agent.

[0152] For each dedicated processing agent's current execution progress snapshot, calculate the total number of allocated task fragments Ntotal = Nfin + Npend, where Nfin is the value of the completed quantity key and Npend is the value of the pending quantity key. Calculate the actual execution progress percentage Rprog = Nfin / Ntotal; if Ntotal is 0, then Rprog is 1.

[0153] Step S712: In the task distribution path sequence, determine the dedicated processing agent with the fastest execution progress and the dedicated processing agent with the slowest execution progress. Calculate the difference between the actual execution progress ratio of the dedicated processing agent with the fastest execution progress and the actual execution progress ratio of the dedicated processing agent with the slowest execution progress. If the difference exceeds the preset progress difference threshold, mark the dedicated processing agent with the slowest execution progress as a lagging agent.

[0154] Sort the actual execution progress ratios Rprog of all dedicated processing agents in descending order of their numerical values. The dedicated processing agent identifier of the first element after sorting is taken as the fastest-performing dedicated processing agent, and its actual execution progress ratio is denoted as Rfast. The dedicated processing agent identifier of the last element after sorting is taken as the slowest-performing dedicated processing agent, and its actual execution progress ratio is denoted as Rslow. Calculate the progress difference Dprog = Rfast - Rslow. Compare Dprog with a preset progress difference threshold Dth. If Dprog > Dth, then mark the slowest-performing dedicated processing agent as a lagging agent, and write its dedicated processing agent identifier into the lagging agent identifier variable.

[0155] Step S713: Select transferable task fragments from the queue of task fragments to be executed by the lagging agent. The transferable task fragments are those whose preconditions have been met and which have no data dependency relationship with the task fragments being executed by the lagging agent. Remove the transferable task fragments from the queue of task fragments to be executed by the lagging agent.

[0156] The task scheduling agent extracts a queue list of pending task fragments from the current execution progress snapshot of the lagging agent. For each pending task fragment in the list, it checks the completion status of its preconditions in the current global dependency graph. If the status flag of all the preceding task fragments of the pending task fragment is SUCCESS, then the preconditions have been met. Next, it checks whether there is a path connection between the pending task fragment and the task fragment corresponding to the currently executing identifier key being executed by the lagging agent in the global dependency graph. If there are no directed edges connecting them and they do not share any upstream dependent fragments, then it is determined that there is no data dependency. The first pending task fragment that simultaneously satisfies both the preconditions being met and the absence of data dependency is taken out as a transferable task fragment. This transferable task fragment is deleted from the pending task fragment queue list of the lagging agent, and an HTTPDELETE request is used to notify the lagging agent to remove the task fragment from its internal waiting queue.

[0157] Step S714: Select an idle dedicated processing agent from the agent cooperative network that is currently idle and whose fragment type label is consistent with the fragment type label of the transferable task fragment. Assign the transferable task fragment to the queue of task fragments to be executed of the idle dedicated processing agent. Modify the target dedicated agent identifier of the path node corresponding to the transferable task fragment in the task distribution path sequence to the identifier of the idle dedicated processing agent.

[0158] The task scheduling agent sends status query requests to all registered dedicated processing agents in the dedicated agent registry, collecting the current load status returned by each dedicated processing agent. Dedicated processing agents with 0 currently executing task fragments and 0 pending task fragments are selected as idle dedicated processing agents. The idle dedicated processing agent list searches for dedicated processing agents whose fragment type flags in their capability declarations contain the fragment type flag for transferable task fragments. If a matching idle dedicated processing agent is found, the fragment content data and execution parameters of the transferable task fragment are sent to the task receiving endpoint of that idle dedicated processing agent via an HTTP POST request, and the idle dedicated processing agent adds the task fragment to its internal waiting queue. Simultaneously, the task distribution path sequence is traversed to find path nodes where the task fragment identifier matches the fragment identifier of the transferable task fragment, and the value of the target dedicated agent identifier key of that path node is modified to the identifier string of the idle dedicated processing agent.

[0159] Step S810: Extract all currently active collaborative task state nodes from the state storage area of ​​the agent collaborative network, and extract the corresponding task distribution path sequence and the task exception reason code parsed from the task execution feedback message for each collaborative task state node.

[0160] The task scheduling agent traverses the state storage area, filtering all collaborative task state nodes whose state flag field indicates they are currently active. For each collaborative task state node, it reads its associated task distribution path sequence and the list of task exception reason codes parsed from all received task execution feedback messages. The collaborative task state node identifier, task distribution path sequence, and list of task exception reason codes are then organized into an in-memory analysis data structure.

[0161] Step S811: Arrange the task exception reason codes of each collaborative task status node according to the execution order of the path nodes in the task distribution path sequence to generate an exception reason code sequence for each collaborative task status node.

[0162] For each collaborative task status node, iterate through the task fragment identifiers of each path node in its task distribution path sequence, and search for the task exception reason code associated with each task fragment identifier in the task exception reason code list. If a task fragment generates a task exception reason code, record the string of the task exception reason code at the corresponding position in the sequence; if the task fragment executes successfully, record an empty value at the corresponding position in the sequence. Arrange the values ​​at all positions in the execution order of the path nodes to form the exception reason code sequence.

[0163] Step S812: Compare the sequence of abnormal cause codes of all collaborative task status nodes position by position, extract the task abnormal cause codes that appear in the same or adjacent sequence positions in the abnormal cause code sequences of multiple different collaborative task status nodes, and aggregate the extracted task abnormal cause codes into a set of common abnormal cause codes.

[0164] Align each sequence of exception reason codes according to its sequence index position. For each sequence position, count the frequency of each task exception reason code string appearing at that position. For each pair of adjacent positions, count the frequency of the task exception reason code combination appearing simultaneously in the adjacent position pair. If the frequency of a task exception reason code appearing at the same sequence position in multiple collaborative task status nodes exceeds a preset common occurrence frequency threshold, add it to the common occurrence exception reason code set. If the frequency of a task exception reason code combination appearing at adjacent sequence positions in multiple collaborative task status nodes exceeds a preset common occurrence frequency threshold, add both task exception reason codes in the combination to the common occurrence exception reason code set.

[0165] Step S813: For each common anomaly cause code in the common anomaly cause code set, extract the target dedicated agent identifier bound to the path node corresponding to the common anomaly cause code from the task distribution path sequence of each collaborative task status node, and generate a set of competing dedicated agent identifiers associated with the common anomaly cause code.

[0166] For each common anomaly cause code in the common anomaly cause code set, search for the path node that matches the task anomaly cause code in the task distribution path sequence of all cooperative task state nodes, extract the value of the target dedicated agent identifier key of these path nodes, merge and deduplicate all extracted dedicated processing agent identifiers to obtain the set of competing dedicated agent identifiers associated with the common anomaly cause code.

[0167] Step S814: Locate the task fragments in the task distribution path sequence that are assigned to each dedicated processing agent in the set of competing dedicated agent identifiers and carry common occurrence exception cause codes. Add a mutual exclusion execution flag to the triggering conditions of these task fragments in the task distribution path sequence. The mutual exclusion execution flag stipulates that only one task fragment carrying the same mutual exclusion execution flag is allowed to be started by the corresponding dedicated processing agent in the same time segment.

[0168] Traverse the task distribution path sequence of the current collaborative task status nodes. For each dedicated processing agent in the competing dedicated agent identifier set, find the path node where it is assigned to execution and the task exception reason code matches the common exception reason code. Add a mutex execution flag field to the trigger condition key of these path nodes. The value of the mutex execution flag field is the mutex group identifier string calculated by hashing the common exception reason code string. When the task scheduling agent issues a task execution request, it checks whether the trigger condition of the task fragment to be issued contains the mutex execution flag field. If it does, it checks whether other task fragments with the same mutex group identifier already have instances that are executing. If so, it delays the issuance of the task fragment until other task fragments with the same mutex group identifier have completed execution.

[0169] Step S910: After the task scheduling agent performs a state reading operation on the initial state node of the collaborative task and before generating the task distribution path sequence, iterates through all task fragments in the initial state node of the collaborative task, extracts the preconditions, execution boundary parameters and output verification rules of each task fragment, and generates a set of rules to be verified.

[0170] After the task scheduling agent completes the structural decomposition of the initial state node of the collaborative task in step S131, and before starting to generate the fragment processing binding relationship in step S132, it executes the compliance verification process of this step. It iterates through each task fragment entry in the fragment information mapping table, extracts the precondition list, the execution boundary parameter dictionary, and the output verification rule list, and associates these three items with the fragment identifier of the task fragment, as a record of a rule to be verified in the set of rules to be verified.

[0171] Step S911: Access a pre-configured set of task compliance constraint rules from outside the intelligent agent collaborative network. Each compliance constraint rule in the set of task compliance constraint rules includes a combination of prohibited precondition fields and a combination of prohibited output verification fields.

[0172] The task scheduling agent downloads a set of task compliance constraint rules from the compliance rule configuration server via a secure file transfer protocol. The set of task compliance constraint rules is stored as a JSON array, where each element is a compliance constraint rule JSON object. Each compliance constraint rule JSON object contains a prohibited precondition field combination key and a prohibited output validation field combination key. The value of the prohibited precondition field combination key is an array of strings, where each string represents a field name that is not allowed in the preconditions. The value of the prohibited output validation field combination key is also an array of strings, where each string represents a field name that is not allowed in the output validation rule validation field names.

[0173] Step S912: Match the preconditions of each task fragment in the set of rules to be verified with the prohibited precondition field combination of each compliance constraint rule in the set of task compliance constraint rules. If the preconditions of a task fragment contain all the fields in the prohibited precondition field combination of a compliance constraint rule, then mark the task fragment as a precondition violation fragment.

[0174] Iterate through the precondition list of each rule record in the set of rules to be verified. For each compliance constraint rule's array of prohibited precondition field combinations, check if the set of field names in the precondition list that depend on the data produced by the upstream task fragment contains all the strings in the array of prohibited precondition field combinations. If all the strings are contained, mark the corresponding task fragment as a precondition violation fragment, and record the array of prohibited precondition field combinations of the violation compliance constraint rule as a violation field combination.

[0175] Step S913: Match the output verification rule of each task fragment in the set of rules to be verified with the prohibited output verification field combination of each compliance constraint rule in the set of task compliance constraint rules. If the output verification rule of a certain task fragment contains all the fields in the prohibited output verification field combination of a certain compliance constraint rule, then mark the task fragment as an output violation fragment.

[0176] Iterate through the output verification rule list for each record in the set of rules to be verified, and extract the verification field names of all verification rules. For each compliance constraint rule's array of prohibited output verification field combinations, check if the set of verification field names contains all the strings in the array of prohibited output verification field combinations. If it contains all the strings, mark the corresponding task fragment as an output violation fragment, and record the array of prohibited output verification field combinations of the violation compliance constraint rule as a violation field combination.

[0177] Step S914: Perform a precondition replacement operation on the precondition violation fragment. Extract the alternative precondition field from the task constraint set of the initial state node of the collaborative task. The alternative precondition field is semantically equivalent to the prohibited precondition field combination but has a different field name. Replace the violation field in the precondition of the precondition of the precondition with the alternative precondition field.

[0178] For each preceding violation fragment, obtain its combination of violating fields. Search the JSON object of the task constraint set for alternative fields that have the same semantic category label as each field name in the violation field combination but have a different name. Semantic category labels are obtained from a predefined thesaurus of business terms. If a semantically equivalent but differently named alternative field is found, replace the position of the violating field name in the preceding condition list of the preceding violation fragment with the alternative field name. If no alternative field is found, extract the default constraint field associated with each field in the violation field combination from the task constraint set and replace the violating field with the default constraint field.

[0179] Step S915: Perform a production verification rule pruning operation on the produced non-compliant fragments. Remove the verification entries that match the fields in the prohibited production verification field combination from the production verification rules of the produced non-compliant fragments, generate the pruned production verification rules, and write the pruned production verification rules back to the corresponding task fragment in the initial state node of the collaborative task.

[0180] For each produced violation fragment, obtain its violation field combination. Iterate through the produced violation fragment's output verification rule list. If the verification field name string of a certain verification rule is equal to any string in the violation field combination, delete that verification rule from the output verification rule list. After deletion, generate a trimmed output verification rule list. Write the trimmed output verification rule list back to the output verification rule key value of the task fragment node object in the initial state node of the collaborative task. After completing all correction operations in steps S914 and S915, re-execute the verification process from steps S910 to S913 until there are no more preceding violation fragments or produced violation fragments in the set of rules to be verified.

[0181] Step S1010: After the initial state node of the collaborative task is written into the agent collaborative network and before the task scheduling agent performs a state reading operation on the initial state node of the collaborative task, perform a fragment complexity quantification operation on each task fragment in the initial state node of the collaborative task.

[0182] After the task scheduling agent completes the writing of the initial state node of the collaborative task into the state storage area in step S128, and before performing the state reading operation in step S131, it performs the fragmentation complexity quantification and merging optimization process of this step.

[0183] Step S1011: The fragment complexity quantification operation includes counting the pre-task fragment identifiers in the pre-conditions of the task fragment to obtain the pre-dependency count, counting the verification entries in the output verification rules of the task fragment to obtain the output verification count, and adding the pre-dependency count and the output verification count to obtain the static complexity value of the task fragment.

[0184] For each task fragment node object in the initial state node of the collaborative task, read the array length corresponding to the value of its precondition key and assign the array length to the precondition count Cdep. Read the array length corresponding to the value of its output verification rule key and assign the array length to the output verification count Cchk. The static complexity value of this task fragment is Cstatic = Cdep + Cchk.

[0185] Step S1012: Extract the state transition log sequence of the task fragment in the completed business process from the state storage area of ​​the agent cooperative network. Count the cumulative number of times the task fragment is marked as a faulty fragment from the state transition log sequence. Count the cumulative number of times the task fragment is redistributed to different dedicated processing agents. Add the cumulative number of times the task fragment is marked as a faulty fragment to the cumulative number of times it is redistributed to different dedicated processing agents to obtain the dynamic complexity value of the task fragment.

[0186] Using the fragment type marker of this task fragment as the query condition, search for fault marker records of task fragments containing this fragment type marker from the state transition log sequences of all completed business processes in the state storage area. Calculate the cumulative number of times the fragment type marker is marked as a faulty fragment (Nfault). Calculate the cumulative number of times the fragment type marker is recorded as a change in the target dedicated agent identifier (Nreass). The dynamic complexity of this task fragment is Cdyn = Nfault + Nreass.

[0187] Step S1013: Normalize the static and dynamic complexity values ​​of each task fragment, and perform weighted fusion according to preset weights to obtain the comprehensive complexity value of the task fragment. Sort all task fragments in descending order of comprehensive complexity value. Mark the task fragments that are at the beginning of the sorted sequence and whose comprehensive complexity value is greater than the average of the comprehensive complexity values ​​of all task fragments in the initial state node of the collaborative task as fragments that need to be merged and evaluated.

[0188] The static complexity values ​​of all task fragments are normalized to their maximum value: Cstatic_norm = Cstatic / max(Cstatic). The dynamic complexity values ​​are also normalized to their maximum value: Cdyn_norm = Cdyn / max(Cdyn). The overall complexity value is Ccomp = w × Cstatic_norm + (1-w) × Cdyn_norm, where w is a preset static weight. The average value Cavg of the overall complexity values ​​of all task fragments is calculated. All task fragments are sorted in descending order of Ccomp, and the task fragments that are in the top preset proportion after sorting and whose Ccomp > Cavg are marked as fragments that need to be merged and evaluated.

[0189] Step S1014: Extract task fragment pairs with the same fragment type label from the fragments to be merged and evaluated. Perform a precondition overlap analysis on each pair of task fragment pairs with the same fragment type label. The precondition overlap analysis calculates the ratio of the number of intersection elements to the number of union elements of the precondition fragment identifier sets of the two task fragments in the task fragment pair. Task fragment pairs with a ratio greater than a preset overlap threshold are identified as mergeable fragment pairs.

[0190] The sets of fragments to be merged and evaluated are grouped according to fragment type. Any two different task fragments with the same fragment type label within each group form a task fragment pair. For each task fragment pair, the prerequisite task fragment identifiers contained in the prerequisite condition lists of the two task fragments are extracted to form two sets S1 and S2. The prerequisite condition overlap ratio Rover = |S1∩S2| / |S1∪S2|, where |·| represents the number of elements in the set. If Rover > Rth, then the task fragment pair is determined to be a mergeable fragment pair, where Rth is a preset overlap ratio threshold.

[0191] Step S1015: Perform a fragment merging operation on the mergeable fragment pair. The fragment merging operation includes taking the union of the sets of the predecessor task fragment identifiers of the two task fragments in the mergeable fragment pair as the predecessor condition after merging, taking the union of the sets of output verification rule entries of the two task fragments in the mergeable fragment pair as the output verification rule after merging, splicing the fragment content data of the two task fragments in the mergeable fragment pair as the fragment content data after merging, generating the merged task fragment, and replacing the two task fragments in the mergeable fragment pair with the merged task fragment.

[0192] For two task fragments A and B in a mergeable fragment pair, the preconditions after merging are: the union of the sets of preconditions for task fragments A and B; the output validation rules after merging are the concatenated list of output validation rules for A and B; the fragment content data after merging is the result of merging the top-level keys of the JSON objects containing the fragment content data of A and B; the maximum waiting time for the execution boundary parameters after merging is the larger of the maximum waiting times of A and B; a new fragment identifier is generated as the identifier for the merged task fragment; the merged task fragment is inserted into the initial state node of the collaborative task; the original task fragments A and B are deleted; and the start and end node identifiers of the directed edges related to A and B in the initial structure graph of the collaborative task are updated.

[0193] Step S1016: Combine the unmerged task fragments and merged task fragments in the initial state node of the collaborative task into a simplified fragment set. Re-execute the pre-dependency analysis on the simplified fragment set to generate a simplified global pre-dependency graph. Generate a simplified task distribution path sequence based on the simplified global pre-dependency graph. Configure task execution duration parameters for the path nodes corresponding to the merged task fragments in the simplified task distribution path sequence. The task execution duration parameter is the sum of the longest waiting times in the execution boundary parameters of the two task fragments in the mergeable fragment pair replaced by the merged task fragment.

[0194] Perform the same global prerequisite dependency graph construction operation as in step S133 on the simplified fragment set to generate a simplified global prerequisite dependency graph. Perform the same distribution path sequence generation operation as in steps S134 to S138 on the simplified global prerequisite dependency graph to obtain a simplified task distribution path sequence. In the simplified task distribution path sequence, find the path node whose fragment identifier is equal to the identifier of the merged task fragment, read the value with the key "longest waiting time" from the dictionary of execution boundary parameters for merging task fragments, and set it as the sum of the longest waiting time of fragment pair A and fragment pair B. Output the simplified task distribution path sequence as the final task distribution path sequence to step S139 to continue execution.

[0195] Figure 2 It showcases business scenarios including multi-channel operational backend interfaces, as well as the composition and task state evolution logic of the intelligent agent collaborative network. Figure 2 On the left, the operations backend interface receives and outputs three types of configuration request data: text description data, image material data, and numerical range setting data, pointing towards the central intelligent agent collaborative network. This collaborative network is centered on a task scheduling intelligent agent, surrounded by text generation intelligent agents, image processing intelligent agents, pricing strategy intelligent agents, and inventory configuration intelligent agents. The intelligent agents are connected by bidirectional arrows, and each agent's processed output is labeled at its corresponding position. Figure 2 The middle section displays a timeline, along which are arranged the initial state nodes of the collaborative task, the subsequent state nodes of the collaborative task, and the deep error correction state nodes of the collaborative task. Below each node, the corresponding task fragment set and prerequisite dependency graph, the corrected task fragment and updated distribution path, and the subtask fragment and re-topology sorting are indicated. Figure 2 The bottom shows the complete e-commerce event page and its simultaneous launch on multiple channels and platforms. Figure 2 It also demonstrates a closed-loop feedback arrow from the completed activity page to the top-left configuration interface, and highlights the optimized state transition trajectory feedback. (The above...) Figure 2 The presented modules and data flow logic are related to the reception of configuration request data in step S110, the construction of task fragments and generation of initial state nodes in step S120, and the establishment of task distribution paths and feedback channels in step S130.

[0196] Figure 3 This demonstrates the parsing process of configuration request data, the logic for generating task fragments, and the method for constructing the initial structure diagram of collaborative tasks. Figure 3 At the top, the text description data is parsed to extract entities such as product name, activity rules, and display text, and an association structure is established between entities through applicable and corresponding relationships. Image material data is segmented into regions, and the pixel sequence of foreground object edges and the background color fill pattern are extracted separately. Numerical range setting data is broken down into product pricing range, inventory configuration range, and promotional discount range. The parsing results of these three types of data are used as input and aggregated into... Figure 3 The central task fragment generator generates multiple task fragments based on fragment type tags. Figure 3 At the bottom, these task fragments are organized into a collaborative task initial structure diagram according to their execution order and input-output connections. The diagram labels the preconditions, execution boundary parameters, and output verification rules for each individual task fragment, and encapsulates all fragments into a collaborative task initial state node. The above... Figure 3The complete process presented, from data parsing to node encapsulation, corresponds to the operation in step S120 of constructing the initial state node of the collaborative task and its constraint set and completion benchmark set based on the configuration request data.

[0197] Figure 4 This demonstrates the specific process of task distribution and execution, exception handling, and dynamic updating of status nodes. Figure 4 In the left-side task distribution and execution scenario, the task scheduling agent distributes task fragments to specialized processing agents such as document processing, image processing, pricing processing, and inventory processing. When an agent encounters an error during execution, Figure 4 The central section showcases the anomaly feedback mechanism. Feedback messages include task status markers, task output data packets, and task anomaly reason codes. A state transition trigger command is generated by comparing the deviation from the task completion baseline with the dashboard. This command drives the subsequent status nodes of the collaborative task in the right panel to perform path rearrangement operations, specifically including task fragment replacement, parameter adjustment, updating the task distribution path sequence, and activating a backup agent. Figure 4 A circular feedback loop is drawn at the bottom, linking the execution result with state transition mapping table updates, anomaly cause code frequency statistics, path correction success rate distribution, state transition trajectory feedback learning, and dynamic optimization of path selection weights. Figure 4 The task distribution, feedback collection, and state transition logic shown corresponds to the establishment of the task distribution path sequence and state feedback channel in step S130, the feedback parsing and deviation comparison and generation of state transition trigger instructions in step S140, and the state node update and distribution path rearrangement operations in step S150.

[0198] Figure 5 This demonstrates how the above methods are presented on the console interface. Figure 5The top of the interface features channel identifiers for Web, App, and Mini Program versions, along with operation buttons for saving configurations, exporting templates, and executing workflows. The business process builder on the left side of the interface includes entity input areas for text description data, image upload and thumbnail display areas for image materials, and slider controls for setting product pricing ranges, inventory configuration ranges, and promotional discount ranges. The central visual canvas displays the initial state node of collaborative tasks, containing task fragments such as text generation, image cropping, price calculation, and inventory verification, as well as an overview of task constraints and completion benchmarks. Circular icons representing dedicated processing agents are also distributed across the canvas. In the attribute configuration and real-time feedback panel on the right side of the interface, the preconditions area displays the dependencies of the current node in a tree diagram, the execution boundary area has input boxes for the maximum waiting time and the number of consecutive retries, and the output verification area is configured with a data format matching template. Under the Real-Time Feedback tab, the Status Feedback channel displays the task status markers of each agent in a scrolling manner. The Deviation Analysis dashboard displays the deviation comparison results and deviation field descriptions in real time. The State Transition Control Area lists candidate state transition paths and provides an execution button to confirm the transition to the subsequent state. The bottom status bar displays the current task ID, creation time, and resource monitoring bar charts for each agent. The interaction logic and functional areas of this console interface correspond to the input of configuration data, monitoring of status nodes, receiving of feedback messages, viewing of deviation comparison results, and selection and execution of state transition paths in steps S110 to S150, respectively.

[0199] Furthermore, an automated business process execution system based on multi-agent collaboration provided in this application embodiment includes a processor and a memory. The processor and memory are connected, for example, via a bus. Optionally, the automated business process execution system based on multi-agent collaboration may further include a transceiver, which can be used for data interaction between this automated business process execution system and other automated business process execution systems based on multi-agent collaboration, such as sending and / or receiving data. It should be noted that in actual scheduling, the transceiver is not limited to one, and the structure of this automated business process execution system based on multi-agent collaboration does not constitute a limitation on the embodiments of this application.

[0200] The memory stores program code for executing the embodiments of this application, and its execution is controlled by a processor. The processor executes the program code stored in the memory to implement the steps shown in the foregoing method embodiments.

[0201] The above description is only an optional implementation method for some implementation scenarios of this application. It should be noted that for those skilled in the art, other similar implementation methods based on the technical concept of this application, without departing from the technical concept of this application, also fall within the protection scope of the embodiments of this application.

Claims

1. A method for automating business process execution based on multi-agent collaboration, characterized in that, The method includes: Receive configuration request data for pending business on a multi-channel platform. The configuration request data includes text description data, image material data, and numerical range setting data. Based on the configuration request data, a collaborative task initial state node is constructed. The collaborative task initial state node is written into a preset agent collaborative network through a task scheduling agent. The collaborative task initial state node carries a set of task constraints and a set of task completion benchmarks. The task scheduling agent performs a status reading operation on the initial state node of the collaborative task, generates a task distribution path sequence and a task status feedback channel identifier for the initial state node of the collaborative task, and sends the task data fragments extracted from the initial state node of the collaborative task along the task distribution path sequence to multiple dedicated processing agents corresponding to the task type. The task execution feedback message is received from the multiple dedicated processing agents on the channel indicated by the task status feedback channel identifier. The task scheduling agent parses the task status flag, task output data packet and task exception reason code from the task execution feedback message, and compares the task status flag with the corresponding benchmark entry in the task completion benchmark set to generate a state transition trigger instruction. Based on the state transition triggering instruction, a corresponding state transition path is selected in the agent cooperative network. The task scheduling agent is driven to update the initial state node of the cooperative task to the subsequent state node of the cooperative task along the state transition path. Under the subsequent state node of the cooperative task, the task distribution path sequence is rearranged based on the task output data packet and the task exception reason code to generate an updated task distribution path sequence. The task output data packet is used as the task context constraint when the multiple dedicated processing agents execute the task again.

2. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The step of constructing a collaborative task initial state node based on the configuration request data, and writing the collaborative task initial state node into a preset agent collaborative network through a task scheduling agent, includes: Text entities are extracted from the text description data in the configuration request data to generate a text entity list and a text entity relationship list. The text entity list includes product name entity, activity rule entity and display text entity. The text entity relationship list describes the applicability relationship between product name entity and activity rule entity and the correspondence relationship between product name entity and display text entity. The image material data in the configuration request data is divided into image regions to generate region segmentation boundaries and pixel statistical distribution within the regions. Based on the region segmentation boundaries, foreground image regions and background image regions are determined. Foreground object edge pixel sequences are extracted from the foreground image regions, and background color fill patterns are extracted from the background image regions. The numerical range setting data in the configuration request data is decomposed into numerical intervals to generate a product pricing interval, an inventory configuration interval, and a promotional discount interval. The product pricing interval includes a price start boundary value and a price end boundary value. The inventory configuration interval includes an inventory reservation start value and an inventory reservation end value. The promotional discount interval includes a discount percentage start value and a discount percentage end value. Input the text entity list, the region segmentation boundary, the foreground object edge pixel sequence, the background color fill mode, the product pricing range, the inventory configuration range, and the promotional discount range into the task fragment generator to generate multiple task fragments. Each task fragment carries a fragment type tag and fragment content data. Based on the fragment type markers and fragment content data carried by each of the multiple task fragments, the execution order and input-output connection relationship between the multiple task fragments are determined, and an initial structure diagram of the collaborative task is generated according to the execution order and the input-output connection relationship. Preconditions are set for each task fragment in the initial structure diagram of the collaborative task, and the preconditions are the completion status marker of the upstream task fragment on which the task fragment depends and the output data availability marker of the upstream task fragment. An execution boundary parameter is set for each task fragment in the initial structure diagram of the collaborative task. The execution boundary parameter includes the maximum waiting time of the task fragment and the number of consecutive retries allowed for the task fragment. For each task fragment in the initial structure diagram of the collaborative task, output verification rules are set, and the output verification rules include the data format requirements and data content matching templates of the task fragment output; All task fragments in the initial structure diagram of the collaborative task, which carries the preconditions, the execution boundary parameters, and the output verification rules, are encapsulated into state nodes to generate the initial state node of the collaborative task. The initial state node of the collaborative task is then sent to the task scheduling agent, which writes the initial state node of the collaborative task into the state storage area of ​​the agent's collaborative network.

3. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The step of performing a status read operation on the initial state node of the collaborative task through the task scheduling agent, and generating a task distribution path sequence and a task status feedback channel identifier for the initial state node of the collaborative task, includes: The task scheduling agent deconstructs the initial state node of the collaborative task, extracts all task fragments contained in the initial state node of the collaborative task, and the fragment type label, preconditions, execution boundary parameters and output verification rules carried by each task fragment. Based on the fragment type tag carried by each task fragment, a dedicated processing agent with corresponding processing capabilities is searched from a preset dedicated agent registry to generate a fragment processing binding relationship. The fragment processing binding relationship describes the processing correspondence between the task fragment and the dedicated processing agent. A global prerequisite dependency graph is constructed based on the prerequisite conditions carried by each task fragment. The nodes of the global prerequisite dependency graph are the task fragments, and the directed edges of the global prerequisite dependency graph indicate that the starting task fragment is a prerequisite dependency of the ending task fragment. Find the set of starting task fragments that do not have any predecessor edges from the global predecessor dependency graph, and mark the starting task fragments in the set of starting task fragments as immediately dispatchable. Find the set of successor task fragments with predecessor edges from the global predecessor dependency graph, and mark the successor task fragments in the set of successor task fragments as waiting to be triggered. The waiting to be triggered state indicates that the task fragments can only be dispatched after the execution completion event of the predecessor task fragment is triggered. Based on the fragment processing binding relationship, the task fragments in the immediately distributable state are assigned to the corresponding dedicated processing agents to generate a first-level distribution task set; Based on the fragment processing binding relationship and the global pre-dependency graph, the task fragments in the waiting-to-trigger state are sorted from shallow to deep according to the dependency level to generate a multi-level serial distribution sequence. Each level of the multi-level serial distribution sequence corresponds to a dependency level. The first-level task distribution set and the multi-level serial distribution sequence are concatenated according to the distribution order to generate the task distribution path sequence. Each path node in the task distribution path sequence includes a task fragment identifier, a target dedicated intelligent agent identifier, and a triggering condition. The task scheduling agent creates a message listening port in the agent cooperative network and assigns a task status feedback channel identifier to the message listening port. The task status feedback channel identifier is then bound to all path nodes in the task distribution path sequence, so that the status feedback generated by the task fragments executed along the task distribution path sequence converges to the listening channel indicated by the task status feedback channel identifier.

4. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The task execution feedback message received from the plurality of dedicated processing agents is received on the channel indicated by the task status feedback channel identifier. The task scheduling agent parses the task status flag, task output data packet, and task exception reason code from the task execution feedback message, including: The task scheduling agent continuously monitors the message channel indicated by the task status feedback channel identifier and receives the original feedback data stream pushed by the multiple dedicated processing agents after their respective task fragments have been executed. The original feedback data stream includes the sender agent identifier and message body data. Based on the sender agent identifier, the corresponding task fragment identifier is retrieved from the task distribution path sequence, and the task fragment identifier is associated with the message body data in the original feedback data stream for storage, generating message body data with task fragment identifier. The message structure of the message body data with task fragment identifier is decomposed, and the task execution result marker field in the header area of ​​the message body data is extracted. The task execution result type is determined based on the value of the task execution result marker field. The task execution result type includes normal completion type and abnormal interruption type. When the task execution result type is normal completion, the task output data packet is extracted from the message payload area of ​​the message body data with task fragment identifier, and the task output data packet is bound and stored with the corresponding task fragment identifier; when the task execution result type is abnormal interruption, the task abnormality detail data segment is extracted from the message payload area of ​​the message body data with task fragment identifier, and the task abnormality reason code is parsed from the task abnormality detail data segment. The task abnormality reason code includes data format conflict code, external interface call failure code, and execution timeout overflow code; when the task execution result type is abnormal interruption, the task fragment corresponding to the task abnormality reason code is marked as a faulty fragment, the downstream dependent task fragment set of the faulty fragment is located from the task distribution path sequence, and a suspended execution flag is set for all task fragments in the downstream dependent task fragment set; The task status flag, the task output data packet, and the task exception reason code are input into the deviation analysis module of the task scheduling agent. The deviation analysis module compares the task status flag with the output verification rules in the initial state node of the collaborative task item by item to generate a deviation analysis result. The deviation analysis result includes a deviation fragment identifier and a deviation field description. The deviation analysis results, the task output data packet, and the task anomaly cause code are combined and encapsulated to generate the state transition trigger instruction.

5. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The step of selecting a corresponding state transition path in the agent cooperative network according to the state transition trigger instruction, and driving the task scheduling agent to update the initial state node of the cooperative task to the subsequent state node of the cooperative task along the state transition path, includes: Extract the deviation fragment identifier, deviation field description, task exception reason code, and task output data packet from the state transition trigger instruction; Based on the deviation fragment identifier, locate the task fragment to be corrected in the initial state node of the collaborative task, associate the task fragment to be corrected with the deviation field description, and generate a tuple of description of the fragment to be corrected. The system queries a preset state transition mapping table based on the task exception reason code. The state transition mapping table stores the mapping relationship between exception reason codes and state transition paths. Based on the query results, a set of candidate state transition paths is determined. The set of candidate state transition paths includes task fragment replacement paths and task fragment parameter adjustment paths. For each candidate state transition path in the candidate state transition path set, a path selection weight is calculated. The path selection weight is determined by using the deviation type described in the deviation field of the fragment description tuple to be corrected, and the historical correction success rate of the candidate state transition path as the matching dimension and the statistical dimension, respectively. The candidate state transition path with the highest path selection weight is selected as the target state transition path. The target state transition path includes the target state node type and state node attribute modification operations. In the agent cooperative network, a blank cooperative task successor state node with the same type as the target state node is created, and normal task fragments that are not marked as task fragments to be corrected in the initial state node of the cooperative task are copied to the blank cooperative task successor state node as is. The state node attribute modification operation contained in the target state transition path is executed on the task fragment to be corrected. The state node attribute modification operation includes modifying the preconditions of the task fragment to be corrected, modifying the execution boundary parameters of the task fragment to be corrected, and modifying the output verification rules of the task fragment to be corrected. The modified task fragment is then written into the subsequent state node of the blank collaborative task. The task output data packet is used to fill the input data slots of the downstream task fragments that have an input-output connection relationship with the task fragment to be corrected in the successor state node of the collaborative task, and the state of the initial state node of the collaborative task in the agent collaborative network is marked as a transferred state, and the successor state node of the collaborative task is activated as the currently active state node.

6. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The step of rearranging the task distribution path sequence based on the task output data packet and the task exception reason code at the subsequent state node of the collaborative task to generate an updated task distribution path sequence includes: Extract the current preconditions and current execution boundary parameters of all task fragments from the successor state node of the collaborative task, and reconstruct the global precondition dependency graph corresponding to the successor state node of the collaborative task based on the current preconditions; The task exception cause code is mapped to a task fragment avoidance strategy. The task fragment avoidance strategy is used to isolate the downstream task fragments of the faulty fragment that generates the task exception cause code in the global pre-dependency graph and temporarily remove the downstream task fragments from the original dependency path. The task output data packet is used to replace the input data slots of the task fragments in the waiting-to-be-triggered state in the global prerequisite dependency graph, and the prerequisite conditions of the replaced task fragments are marked as satisfied. The global pre-dependency graph after path isolation and data replacement is topologically sorted to generate a new multi-level task execution sequence. In the new multi-level task execution sequence, task fragments carrying task fragment avoidance strategies are redistributed to backup dedicated processing agents. The backup dedicated processing agents have the same fragment type marking and processing capabilities as the original dedicated processing agents. The binding relationship between the unreassigned task fragments and the original dedicated processing agent remains unchanged. Only the triggering conditions of the unreassigned task fragments in the new multi-level task execution sequence are updated. The updated binding relationship and the updated triggering conditions are written into the task distribution path sequence to generate the updated task distribution path sequence. Each path node in the updated task distribution path sequence is rebound to the task status feedback channel identifier, so that the status feedback generated during the execution of the updated task distribution path sequence continues to converge to the listening channel indicated by the task status feedback channel identifier.

7. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The method further includes: After the updated task distribution path sequence is sent to the corresponding dedicated processing agent, the secondary execution feedback messages of the multiple dedicated processing agents on the updated task distribution path sequence are continuously received on the channel indicated by the task status feedback channel identifier. The secondary execution feedback messages include secondary task status flags, secondary task output data packets and secondary task exception reason codes. The secondary task status marker is compared with the output verification rule of the corresponding task fragment in the subsequent status node of the collaborative task. If the secondary deviation comparison result indicates that there is still a task fragment execution failure, the secondary anomaly feature is extracted from the secondary task anomaly reason code. Based on the secondary anomaly feature, a deep error correction strategy is selected from the preset deep error correction strategy library. The deep error correction strategy includes a dedicated processing agent capability reconfiguration operation and a task fragment fine-grained splitting operation. The internal processing logic parameters of the dedicated processing agent that generates the secondary task exception reason code are adjusted according to the capability reconfiguration operation of the dedicated processing agent, and the adjusted internal processing logic parameters are synchronized to the corresponding dedicated processing agent. According to the fine-grained task fragment splitting operation, the failed task fragment is split into multiple sub-task fragments. Each sub-task fragment carries an independent sub-precondition and sub-output verification rule. The multiple sub-task fragments are inserted into the subsequent state node of the collaborative task to generate a collaborative task deep error correction state node. Under the deep error correction state node of the collaborative task, the global prerequisite dependency graph is reconstructed, all task fragments and subtask fragments in the deep error correction state node of the collaborative task are re-topologically sorted, a deep error correction task distribution path sequence is generated, and the deep error correction task distribution path sequence is sent down for execution.

8. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The method further includes: In the agent cooperative network, the state transition trajectory between the initial state node of the cooperative task, the subsequent state node of the cooperative task, and the deep error correction state node of the cooperative task is recorded, and the state transition trajectory is stored as a state transition log sequence, which includes the trigger reason code and path selection result for each state transition; Frequency statistics are performed on the trigger reason codes in the state transition log sequence to generate an anomaly reason code frequency distribution, which describes the frequency of occurrence of various anomaly reason codes during the state transition process; The path selection results in the state transition log sequence are evaluated for path effectiveness, and a path correction success rate distribution is generated. The path correction success rate distribution describes the success rate of various state transition paths in correcting task fragments. The frequency distribution of the anomaly cause code and the success rate distribution of the path correction are fed back to the maintenance interface of the state transition mapping table. After normalizing the frequency distribution of the anomaly cause code and the success rate distribution of the path correction, the mapping weight between the anomaly cause code and the state transition path in the state transition mapping table is adjusted according to the normalized feedback result.

9. The method for automating business process execution based on multi-agent collaboration according to claim 1, characterized in that, The method further includes: At the message listening port of the task scheduling agent, the execution time data and computing resource consumption data of each time the multiple dedicated processing agents execute task fragments are collected to generate a single execution overhead record. The single execution overhead records are aggregated according to the dedicated processing agent identifier and fragment type label to generate an agent fragment processing capability profile. The agent fragment processing capability profile includes the average processing time and average resource consumption of each dedicated processing agent for different fragment type labels. When it is necessary to assign a dedicated processing agent to the task fragment in the initial state node or the subsequent state node of the collaborative task, query the fragment processing capability profile of the agent and select a dedicated processing agent whose average processing time is less than the processing time threshold as a candidate allocation object. Among the candidate allocation objects, a dedicated processing agent with an average resource consumption less than the resource consumption threshold is selected as the target task execution agent, and the task fragment is allocated to the target task execution agent.

10. A business process automation execution system based on multi-agent collaboration, characterized in that, The method includes a processor and a computer-readable storage medium storing machine-executable instructions, which, when executed by the processor, implement the business process automation execution method based on multi-agent collaboration as described in any one of claims 1-9.

Images