An agent workflow orchestration method and platform for industrial scene task chain link verification

Abstract

The application belongs to the technical field of program arrangement, and discloses an intelligent agent workflow arrangement method and platform for industrial scene task link verification, a three-layer industrial task link meta-model containing a basic state predicate layer, a process constraint predicate layer and a flow axiom predicate layer is constructed from top to bottom through first-order predicate logic, industrial verification specifications are disassembled into atomic verification rules in the form of Horn clauses and predicate mapping correlation is established, native unification of verification semantics and task semantics is realized at the meta-modeling level, when the node topology and flow conditions of the task link change, the system can automatically complete logical deduction based on the predicate dependency graph, synchronously adjust the scope of action, trigger conditions and constraint strength of the verification axiom, and the verification logic automatically links with the change of the meta-model semantics; the standardized logical expression system realizes cross-scene reuse of verification rules, and different task links can directly call the axiom units in the verification rule library.

Description

Technical Field

[0001] This invention belongs to the field of program orchestration technology, specifically a smart agent workflow orchestration method and platform for task link verification in industrial scenarios. Background Technology

[0002] The current industrial workflow technology system has formed several mature technical paths. Existing technologies have been extensively researched around BPMN modeling, low-code orchestration, and multi-agent scheduling. However, the following technical problems still exist in the underlying technical paradigm: Existing industrial workflows are mostly built on process-based meta-models, which only describe node topology and flow rules, without natively defining task state semantics and constraint axioms at the meta-model layer. Validation rules can only be accessed through manually hard-coded nodes. When the process or validation rules change, the process topology and validation logic need to be modified simultaneously. There is no semantic linkage mechanism between the two, and the cost of change increases non-linearly with the complexity of the link.

[0003] Existing verification methods are mostly result-oriented black-box threshold assertions, which do not conduct formal specifications and reachability verification for link state transitions and process invariants. Implicit logical errors such as data flow misalignment and state out-of-bounds errors cannot be identified in advance. Moreover, verification and orchestration belong to different technology stacks and lack a unified semantic intermediate layer. The improvement of verification coverage will inevitably be accompanied by an exponential increase in orchestration complexity, resulting in an inherent contradiction between reliability and maintainability.

[0004] Existing multi-agent orchestration schedules verification agents as ordinary execution nodes, without defining standardized behavioral contracts for execution agents and verification agents, resulting in their output semantics not being automatically aligned; in multi-agent concurrent scenarios, there is a lack of a global timing guarantee mechanism, and verification data and execution data are prone to spatiotemporal misalignment.

[0005] Existing workflow iterations only focus on optimizing performance parameters such as scheduling timing and resource allocation. Logical defects discovered during verification cannot be mapped back to semantic-level corrections of the orchestration model. Similar logical defects are prone to recurrence in different tasks. The orchestration system can only achieve iteration at the parameter level and cannot achieve self-evolution at the model architecture level. Summary of the Invention

[0006] The purpose of this invention is to provide an intelligent agent workflow orchestration method and platform for task link verification in industrial scenarios, so as to solve one or more problems mentioned in the background art.

[0007] To achieve the above objectives, the present invention provides the following technical solution: an intelligent agent workflow orchestration method for task link verification in industrial scenarios, including a semantic modeling stage, a contract matching stage, an orchestration generation stage, a formal verification stage, an operation control stage, a model calibration stage, and a system evolution stage; Furthermore, in the semantic modeling stage, a three-layer industrial task link meta-model is constructed using first-order predicate logic. From top to bottom, the layers are the basic state predicate layer, the process constraint predicate layer, and the flow axiom predicate layer. The basic state predicate layer defines the standardized logical expression of the input and output data status and resource occupancy status of task nodes. The process constraint predicate layer defines the logical constraint form of quality, accuracy, and safety invariants in industrial scenarios. The flow axiom predicate layer defines a deducible set of axioms for topological dependencies, branching conditions, and merging rules between nodes, transforming the link topological dependencies into logically deducible semantic dependencies. The industrial quality specifications and process constraints in the industrial verification specifications are decomposed into atomic verification specifications in the form of Horn clauses. A one-to-one mapping relationship between the atomic verification specifications and the state predicates of the task nodes is established through predicate binding operators. A verification rule base with semantic axioms is constructed. The atomic verification specifications are stored in the verification rule base as verification axioms after semantic axiomization. When the node topology and flow conditions of the task link change, the system automatically derives based on the predicate dependency graph and synchronously adjusts the scope of application, triggering conditions and constraint strength of the verification axiom. The verification logic automatically links with the semantics of the industrial task link meta-model, realizing the unification of verification semantics and task semantics at the meta-modeling layer, forming the industrial task link meta-model and a reusable verification rule base.

[0008] Furthermore, in the contract matching stage, a hierarchical intelligent agent role pool is constructed, which includes execution-type intelligent agents, verification-type intelligent agents, decision-type intelligent agents, and scheduling-type intelligent agents. A standardized intelligent agent behavior contract is defined for each type of intelligent agent, clarifying the pre-trigger conditions, post-state guarantees, operational invariants, and data interaction interfaces. The agent behavior contract of the execution type intelligent agent is automatically generated by the task node state predicate and flow axiom predicate of the industrial task link meta-model, which provides pre-trigger conditions and post-state guarantees. The agent behavior contract of the verification type intelligent agent is automatically generated by the Horn clause of the atomic verification specification, which provides input data constraints, verification output format and anomaly classification rules. Based on the node semantics of the aforementioned industrial task link meta-model, the binding of corresponding category intelligent agents and task nodes is completed through a semantic consistency matching algorithm. The matching process simultaneously verifies the consistency of the predicate signature and the compatibility of the constraint strength between the intelligent agent's behavioral contract and the node predicate, thus forming a contractual binding relationship between the task node and the corresponding category intelligent agent.

[0009] Furthermore, in the orchestration generation stage, the execution main link topology is generated based on the industrial task link meta-model, and the three types of verification injection positions—state transition boundaries, branch merging points, and key process nodes—are automatically located through state transition entropy calculation and strong connectivity component identification algorithm. After automatically matching the corresponding atomic verification specification and verification class agent according to the mapping relationship of the verification rule base, the verification logic is woven into the state transition time of the corresponding execution node in the manner of semantic aspect. The verification sub-flow and the execution node share the same state predicate context. Combined with the agent behavior contract, the triggering sequence, data context and exception handling interface of the verification node are automatically deduced to generate an integrated orchestration model with unified semantics of the execution sub-flow and the verification sub-flow, forming a verifiable orchestration file.

[0010] Furthermore, in the formal verification stage, the integrated orchestration model is transformed into a finite state transition system. Four core verification properties are defined using computational tree logic: deadlock-free link, full path reachability, global satisfaction of process invariants, and completeness of verification rules. The equivalent states in the state space are clustered and reduced using the process constraint predicates in the industrial task link meta-model. The model detection algorithm traverses the reduced full state space to identify logical conflicts, resource conflicts, and verification coverage vulnerabilities. For verification coverage vulnerabilities, the path coverage of verification axioms is quantified by deducing the satisfiability of Horn clauses, the uncovered state transition paths are located, and the decision-making agent is called to supplement the corresponding verification axioms. To address logic and resource conflicts, the predicates of the flow axiom and the timing constraints are adjusted based on the predicate dependency graph to achieve semantic-level resolution of the conflicts and output a formally verified executable orchestration scheme.

[0011] Furthermore, in the operation and management phase, the verified executable orchestration scheme is deployed to the operating environment, and the scheduling agent triggers the process execution based on the event-driven mechanism. The operation process is based on the agent's behavior contract to maintain the contextual consistency between the execution data and the verification data. For multi-agent concurrent scenarios, a vector clock mechanism is used to label the data with global time series labels, and the state predicate version number of the corresponding node is bound at the same time. Before the verification agent starts the verification, the continuity of the time series labels and the semantic consistency of the state predicate are verified at the same time. If the verification passes, the process flows to the next node according to the agent behavior contract. If the verification fails, a retry, state rollback, or full-link circuit breaker is triggered according to the exception level. During rollback, only the subset of state predicates related to the exception is rolled back based on the predicate dependency graph, while the execution state of unrelated nodes is retained. The entire process is recorded in a full-link semantic log containing state predicate version numbers, time sequence labels, and verification results.

[0012] Furthermore, in the model calibration phase, the execution and verification semantic logs of the entire chain are aggregated to construct an axiomatic semantic tracing chain, and each verification anomaly is mapped to the state predicate, flow axiom predicate, or independent agent behavior contract terms in the industrial task chain meta-model. Inverse reasoning is performed based on the first-order predicate resolution principle to distinguish three types of root causes: missing predicate definitions, loose axiom constraints, and incomplete contract terms. Correspondingly, a model-level calibration scheme is generated, including supplementing the missing corresponding level predicates, correcting axiom predicates with inconsistent constraint strength, and optimizing the agent's behavioral contract. After formal consistency verification, the calibration scheme updates the corresponding predicates and axioms in the industrial task link meta-model and synchronizes them to all orchestration instances that reference the industrial task link meta-model.

[0013] Furthermore, during the system evolution stage, the orchestration scheme that has been verified and operates stably in the field is abstracted into a reusable unit consisting of template fragments, a set of verification axioms, and a set of agent behavior contracts. These units are then classified and deposited into a template knowledge base according to industrial scenarios and task types. The templates, axioms, and contracts within the reusable units maintain semantic alignment. Based on the incrementally accumulated execution and verification data, implicit process invariants and verification rules are extracted through association rule mining, transformed into formal axioms, and then verified to ensure that there is no logical conflict with the verification rule library after axiom consistency verification. The data is then incrementally expanded into the verification rule library and the industrial task link meta-model. Synchronously optimize the semantic axioms of the corresponding orchestration template and the behavioral contract configuration of the agent, and automatically generalize and migrate the defects of the industrial task link meta-model located in a single scenario to all orchestration templates and the industrial task link meta-model in the same scenario.

[0014] This invention also provides an intelligent agent workflow orchestration platform for task link verification in industrial scenarios, which, based on the above method, includes the following units: The semantic modeling unit uses first-order predicate logic to construct an industrial task link meta-model, decomposes industrial verification specifications into atomic verification specifications in the form of Horn clauses and establishes predicate mapping, constructs a verification rule base with semantic axioms, and supports automatic linkage of verification logic as the model topology changes. The agent contract management unit maintains a hierarchical agent role pool, defines standardized agent behavior contracts, and completes consistency matching and binding between agents and task nodes based on the semantics of the industrial task link meta-model. The integrated orchestration generation unit generates the execution main link topology based on the industrial task link meta-model and automatically locates the verification injection position. It weaves in the verification logic in a semantic aspect manner to generate an integrated orchestration model with unified execution and verification semantics. The formal verification unit transforms the integrated orchestration model into a finite state transition system. After state space reduction, it traverses the entire path through model detection, identifies and resolves logical conflicts and verification vulnerabilities, and outputs an executable orchestration scheme. The operation and control unit deploys the executable orchestration scheme and drives the collaborative execution of multiple agents. It maintains data context consistency based on the agent behavior contract, uses vector clocks to ensure spatiotemporal alignment of data in concurrent scenarios, handles execution anomalies in a hierarchical manner, and records full-link semantic logs. The model calibration unit constructs a source tracing link based on the semantic log, deduces the root cause of defects and generates a model-level calibration scheme, and realizes hot updates and full instance synchronization. The system evolves into a unit, precipitates reusable orchestration units, and mines hidden process rules to expand the verification rule base.

[0015] The beneficial effects of this invention are as follows: 1. This invention constructs a three-layer industrial task link meta-model from top to bottom, including a basic state predicate layer, a process constraint predicate layer, and a flow axiom predicate layer, using first-order predicate logic. It decomposes industrial verification specifications into atomic verification specifications in the form of Horn clauses and establishes predicate mapping associations. At the meta-modeling level, it achieves native unification of verification semantics and task semantics. When the node topology and flow conditions of the task link change, the system can automatically complete logical deduction based on the predicate dependency graph, and synchronously adjust the scope of application, triggering conditions, and constraint strength of the verification axioms. The verification logic automatically links with the semantic changes of the meta-model, reducing the operation and maintenance costs caused by process iteration and rule changes. The standardized logical expression system realizes the cross-scenario reuse of verification rules. Different task links can directly call the axiom units in the verification rule library, improving the construction efficiency of industrial workflow orchestration and the semantic consistency of the entire link.

[0016] 2. This invention employs a semantic aspect-based approach to weave verification logic into the state transition moments of the main execution link, generating an integrated orchestration model where the execution sub-flow and verification sub-flow share the same state predicate context. Formal verification methods are used to proactively resolve potential link defects. The integrated orchestration model is transformed into a finite state transition system, defining four core verification properties using computational tree logic: no deadlock in the link, full path reachability, global satisfaction of process invariants, and completeness of verification rules. After state space reduction based on process constraint predicates, the model traverses the entire path, accurately identifying logical conflicts, resource conflicts, and verification coverage vulnerabilities. For vulnerabilities, verification axioms are automatically supplemented; for conflicts, semantic-level resolution is achieved, outputting a completeness-verified executable orchestration scheme. The contractual agent matching mechanism ensures semantic alignment between verification and execution, avoiding semantic deviations caused by the integration of different technology stacks.

[0017] 3. During the operation and management phase of this invention, a vector clock mechanism is used to bind global time-series labels and state predicate version numbers to data. Before verification starts, the temporal continuity and semantic consistency are verified synchronously to ensure the spatiotemporal alignment of verification data and execution data. During anomaly handling, precise subset rollback can be achieved based on the predicate dependency graph, preserving the execution state of irrelevant nodes and reducing execution losses caused by anomalies. During the model calibration phase, through axiomatic semantic tracing links and predicate inversion reasoning, the root cause of defects can be accurately located and a model-level calibration scheme can be generated, which is synchronously updated to all related orchestration instances to avoid the recurrence of similar defects. During the system evolution phase, reusable orchestration units can be accumulated and implicit process rules can be mined to continuously expand the verification rule base and meta-model capabilities. Attached Figure Description

[0018] Figure 1 This is a flowchart illustrating the overall workflow of the intelligent agent workflow orchestration method of the present invention. Figure 2 This is a flowchart of the semantic modeling stage of the present invention; Figure 3 This is a flowchart of the formal verification stage of the present invention. Detailed Implementation

[0019] The technical solution of one embodiment of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0020] like Figures 1 to 3 As shown, this embodiment of the invention provides an intelligent agent workflow orchestration method for task link verification in industrial scenarios; In one embodiment of the present invention, a three-layer industrial task link meta-model is constructed using first-order predicate logic, consisting of a basic state predicate layer, a process constraint predicate layer, and a flow axiom predicate layer from top to bottom. The basic state predicate layer defines the standardized logical expression of the input and output data status and resource occupancy status of task nodes. The process constraint predicate layer defines the logical constraint form of quality, accuracy and safety invariants in industrial scenarios. The flow axiom predicate layer defines a set of deducible axioms of topological dependencies, branching conditions and merging rules between nodes, and transforms the link topological dependencies into logically deducible semantic dependencies. The industrial quality specifications and process constraints in the industrial verification specifications are decomposed into atomic verification specifications in the form of Horn clauses. The decomposition follows three principles: single constraint, minimum granularity, and independent decision-making. Each atomic verification specification corresponds to only one single process constraint decision and does not contain compound logic conditions.

[0021] During the decomposition process, the chapters and clauses of the industrial verification specification are first broken down, and the preconditions and conclusions of each constraint are extracted. The preconditions correspond to the rule body of the Horn clause, and the conclusions correspond to the rule head of the Horn clause. Management and descriptive content that is irrelevant to the process determination is removed.

[0022] For composite verification specifications involving multiple parameters, they are split into multiple independent atomic verification specifications according to the parameter dimension, and each specification only completes the compliance determination of one parameter.

[0023] In industrial settings, the comprehensive quality inspection specification for welding processes can be broken down into three independent atomic verification specifications: weld appearance defect verification, weld size tolerance verification, and weld internal flaw detection verification, each corresponding to different state predicates and trigger nodes.

[0024] A one-to-one mapping relationship between atomic verification specifications and task node state predicates is established by predicate binding operators, and a verification rule base with semantic axioms is constructed. The atomic verification specifications are stored in the verification rule base as verification axioms after semantic axiomization. The predicate binding operator takes the decomposed atomic verification reduction Horn clause and the node state predicate set of the industrial task link meta-model as input and performs a three-step binding operation. The first step is semantic tag matching, which involves extracting the process attribute tags and data type tags of the atomic verification specification, traversing the attribute tag set of the node state predicates, and filtering out candidate predicates with the same semantic tags. The second step is parameter structure alignment, which verifies whether the number of input parameters and data dimensions of the atomic verification specification match the parameter structure of the candidate state predicates, and removes predicates with inconsistent structures. The third step is to solidify the binding relationship, establish a unique binding identifier for the successfully matched verification specification and state predicate, and synchronously record the location of the bound node and the trigger time attribute.

[0025] In industrial scenarios, for the atomic verification specification of the outer diameter tolerance of parts, the operator automatically matches the output outer diameter state predicate of the machining node. After binding, the verification specification is triggered by default at the post-state transition time of the machining node.

[0026] When the node topology and flow conditions of the task link change, the system automatically derives and synchronously generates a verification axiom adjustment scheme based on the predicate dependency graph. The adjustment scheme must be reviewed and confirmed by process personnel before it takes effect. The adjustment content includes the scope of application, triggering conditions, and constraint strength of the verification axiom. The verification logic is automatically linked with the semantics of the industrial task link meta-model, realizing the unification of verification semantics and task semantics at the meta-modeling layer, forming an industrial task link meta-model with a complete semantic axiom system and a reusable verification rule library.

[0027] The predicate dependency graph uses all state predicates, process constraint predicates, flow axiom predicates, and verification axioms in the three-layer industrial task link meta-model as graph nodes, and semantic inference dependency relations as directed edges.

[0028] During the construction phase, dependencies are extracted from industrial process documents and flow rule documents. For example, flow axiom predicates depend on the basic state predicates of their predecessor nodes, verification axioms are bound to the corresponding process constraint predicates and node state predicates, and equipment resource constraint predicates are associated with all task node predicates that occupy the equipment.

[0029] The dependency graph synchronously stores the dependency strength and triggering conditions of each edge. When the task link topology changes, the system traverses the reachable paths in the dependency graph, automatically generates suggestions for adding or removing association verification axioms, and synchronously generates adjustment schemes for the triggering preconditions of the affected axioms. For example, when adding a machining station node, the system automatically associates the corresponding dimensional accuracy process constraint predicates and generates a suggested scheme for binding the corresponding dimensional verification axiom to the post-state of that node. After review and confirmation, the binding is completed.

[0030] In one embodiment of the present invention, a hierarchical intelligent agent role pool is constructed, comprising execution-type intelligent agents, verification-type intelligent agents, decision-making intelligent agents, and scheduling intelligent agents. A standardized intelligent agent behavior contract is defined for each type of intelligent agent, clarifying the pre-trigger conditions, post-state guarantees, operational invariants, and data interaction interfaces. The agent behavior contract of the execution type intelligent agent is automatically generated by the task node state predicate and flow axiom predicate of the industrial task link meta-model, which provides pre-trigger conditions and post-state guarantees. The agent behavior contract of the verification type intelligent agent is automatically generated by the Horn clause of the atomic verification specification, which provides input data constraints, verification output format and anomaly classification rules. When generating the behavior contract of the execution-type intelligent agent, all input state predicates of the corresponding task node are extracted as pre-trigger conditions, all output state predicates of the node and state constraints in the flow axiom are extracted as post-state guarantees, and the resource occupancy constraint predicates associated with the node are extracted as runtime invariants. Standard state reading and state update data interaction interfaces are defined synchronously.

[0031] When generating a behavior contract for a validation agent, the rule body parameter requirements of the corresponding atomic validation Horn clause are extracted as input data constraints, the judgment result structure of the rule header is extracted as the validation output format, the violation level classification rules defined in the specification are extracted as anomaly classification rules, and three types of data interaction interfaces—data acquisition, result reporting, and anomaly triggering—are defined simultaneously.

[0032] In industrial scenarios, the preconditions of the welding station execution-type intelligent agent automatically include two state predicates: the workpiece to be welded is in place and the welding machine is in normal condition. The postconditions automatically include two state predicates: the weld formation is complete and the welding parameters are compliant. The input constraints of the weld quality verification-type intelligent agent automatically match the weld image and current and voltage data predicates output by the welding node. The output format is fixed as three-level judgment results: qualified, minor defect, and serious defect.

[0033] Based on the node semantics of the aforementioned industrial task link meta-model, the binding of corresponding category intelligent agents and task nodes is completed through a semantic consistency matching algorithm. The matching process simultaneously verifies the consistency of the predicate signature and the compatibility of the constraint strength between the intelligent agent's behavioral contract and the node predicate, thus forming a contractual binding relationship between the task node and the corresponding category intelligent agent.

[0034] The semantic consistency matching algorithm takes the state predicate set and constraint predicate set of the industrial task node as input, and the behavior contract precondition set and post-guarantee set of the agent to be matched as the matching object. First, it performs predicate signature matching, compares the number of parameters, parameter type and semantic label of the predicate one by one, and selects candidate agents with signature consistency.

[0035] Next, a constraint strength compatibility check is performed. The constraint range of the node constraint predicate is subset-based, comparing it with the range of operational invariants of the agent contract. If the node constraint is a subset of the agent invariants, it is considered compatible. Finally, the agent instance with the highest matching degree is output, completing the binding with the task node. During the matching process, all predicates use the unified semantic encoding of the aforementioned industrial task link meta-model.

[0036] In one embodiment of the present invention, the main execution link topology is generated based on the industrial task link meta-model, and the three types of verification injection positions—state transition boundary, branch convergence point, and key process node—are automatically located through state transition entropy calculation and strong connectivity component identification algorithm. The state transition entropy calculation takes the number of input state types and the number of output state types of each node in the execution main link topology as input parameters. It calculates the probability of occurrence of all legal input state combinations and the probability of occurrence of all output state combinations of a node, calculates the information entropy values ​​of the input side and the output side respectively, and sums them to obtain the state transition entropy value of the node. Nodes with entropy values ​​higher than a preset threshold are determined as state transition boundaries.

[0037] The strongly connected component identification algorithm traverses the directed graph structure of the main link topology, identifies strongly connected components containing multiple nodes, and determines the entry and exit nodes of the component as branch merging points. At the same time, it reads the nodes marked with key process attributes in the industrial task link meta-model and directly determines them as key process nodes. The three types of nodes are used together as verification injection positions, and outputs the node number and the corresponding state transition time point.

[0038] Formula for calculating node state transition entropy: This represents the entropy value of the state transition of task node v. The higher the entropy value, the more complex the state transition of the node, and the more likely it is to cause state out-of-bounds and flow anomalies. Nodes with entropy values ​​higher than a preset threshold are judged as state transition boundary class verification injection points. This indicates that any task node in the main link topology will be executed; This represents the set of input states for node v, containing all valid combinations of input state predicates for that node. This represents the set of output states of node v, containing all possible combinations of output state predicates for that node, including branch states such as valid, different levels of exception, etc. Indicates that the input state s is in the set The probability of occurrence in the process is obtained based on historical operating data or process flow rules. Indicates that the output state s is in the set The probability of occurrence in; It represents a single state element in the set, corresponding to a specific combination of state predicate values.

[0039] After automatically matching the corresponding atomic verification protocol and verification class intelligent agent according to the mapping relationship of the verification rule base, the verification logic is woven into the state transition time of the corresponding execution node in the manner of semantic aspect. The weaving operation is completed in the state submission stage of the intelligent agent execution layer, which adapts to the timing requirements of the industrial control cycle and does not intrude into the real-time control logic of the underlying device.

[0040] The verification subflow and the execution node share the same state predicate context. Combined with the agent behavior contract, the triggering sequence, data context and exception handling interface of the verification node are automatically deduced to generate an integrated orchestration model with unified semantics between the execution subflow and the verification subflow, forming a verifiable orchestration file.

[0041] The semantic aspect sets three types of cutpoints, corresponding to the three state transition times of the execution node. The first type is the pre-cutpoint, which corresponds to the state transition time before the node starts execution and is used to verify whether the input material parameters, equipment status, and results of the previous process meet the flow requirements. The second type is the post-cutpoint, which corresponds to the state transition time after the node finishes execution and is used to verify whether the output result meets the process quality constraints. The third type is the surrounding cutpoint, which corresponds to the moment before the node state is committed and persisted and is used to verify global resource consistency and concurrency conflicts.

[0042] In industrial scenarios, the pre-cutting point of the machining station verifies the compliance of the blank size and tool parameters, the post-cutting point verifies the dimensional tolerance after machining, and the surrounding cutting point verifies the machine tool occupancy status and the capacity of the next station. The verification subflow obtains data by directly reading the state predicate snapshot of the execution node from memory without additional format conversion. The exception handling interface is directly bound to the state rollback entry of the corresponding node and the alarm channel of the scheduling agent.

[0043] In one embodiment of the present invention, the integrated orchestration model is transformed into a finite state transition system. Four core verification properties are defined using computational tree logic: no deadlock in the link, reachability of the entire path, global satisfaction of process invariants, and completeness of verification rules. The equivalent states in the state space are clustered and reduced through the process constraint predicates in the industrial task link meta-model. The transformation process follows the principle of one-to-one semantic correspondence, mapping all legal state combinations of each task node in the integrated orchestration model to state nodes of the finite state transition system, mapping the flow rules between nodes and the judgment results of the verification logic to state transition edges, using process constraint predicates as guard conditions for the transition edges, binding each state node to the corresponding set of state predicates and resource occupancy set, and labeling each transition edge with trigger events and verification result identifiers.

[0044] In industrial scenarios, the stages of assembly, such as pending assembly, assembly in progress, assembly qualified, and assembly unqualified, are mapped to independent state nodes at the assembly station. Quality inspection passes through the corresponding migration edge to the next station, while quality inspection fails through the corresponding migration edge to the rework node. All migration edges are bound to the guard conditions of the corresponding process constraints.

[0045] Formal definition of the finite state transition system corresponding to the integrated orchestration model: The finite state transition system, which is transformed from the integrated orchestration model, is the input object of the model checking algorithm. It is strictly equivalent to the original orchestration model in semantics. The finite state transition system consists of five components: a set of states, a set of initial states, a set of events, a set of transition relations, and a set of guard conditions. It represents a finite set of states, where each state element corresponds to a set of valid state predicate values ​​and resource usage combinations for task nodes in the orchestration; It represents the initial set of states, corresponding to the global ready states before the task chain starts, and is the starting node for traversing the state space. It represents a finite set of events, including three categories: node transition trigger events, verification result events, and abnormal alarm events. It is the external condition that triggers state transition. Represents the set of state transition relations, belonging to × × A subset of the corresponding nodes, representing the flow rules and decision branches of the verification logic; It represents the set of migration guard conditions, which consists entirely of process constraint predicates from the industrial task link meta-model. The corresponding migration can only be triggered when the guard conditions are met, and it is also used for state space clustering reduction.

[0046] State reduction uses the satisfaction of process constraint predicates as the equivalence criterion. If two different states have completely consistent Boolean decision results on all process constraint predicates, they are determined to be equivalent states and merged into a single state cluster. The reduction process converges layer by layer according to the constraint level. The first round of clustering is completed through safety-level constraint predicates, and the second round of clustering is completed through quality-level constraint predicates. Finally, all boundary states and branch critical states that violate the constraints are retained.

[0047] In industrial scenarios, different discrete values ​​of the temperature at the heating station within the allowable range of the process can be classified into the same equivalence class as long as they all satisfy the temperature compliance constraint predicate. There is no need to enumerate the temperature value states one by one. After reduction, the two boundary states of temperature exceeding the upper limit and below the lower limit are retained to ensure that the verification process does not miss abnormal paths.

[0048] The model detection algorithm traverses the reduced full state space to identify logical conflicts, resource conflicts, and verification coverage vulnerabilities. For verification coverage vulnerabilities, the path coverage of verification axioms is quantified by deducing the satisfiability of Horn clauses. In the derivation process, the preceding state of each state transition path is used as a fact atom and substituted into the Horn clause of the verification axiom to determine whether the path is covered by the verification axiom. The ratio of the number of uncovered state transition paths to the total number of paths is used as the coverage value to locate the uncovered state transition paths. The decision-making agent is then called to supplement the corresponding verification axioms. The satisfiability derivation of the Horn clause takes all the verification axioms of the Horn clauses in the current verification rule base and all the state transition paths of the finite state transition system as inputs, and takes the preceding state of each state transition path as the fact atom, and substitutes it into the verification axioms of the Horn clauses to determine satisfiability. If a certain state transition path cannot be covered by the conclusion atoms of any verification axiom, it is determined to be an uncovered path. The node sequence and state predicate set corresponding to the path are output as the semantic basis for the axiom to be supplemented. The derivation process reuses the predicate semantic system of the industrial task link meta-model throughout.

[0049] The decision-making intelligent agent has a built-in axiom generation module and a consistency verification module. The axiom generation module receives the set of state predicates and the set of process constraint predicates for the uncovered path, and generates candidate verification axioms according to the syntax rules of Horn clauses. The preceding state of the path is used as the rule body and the process constraint requirements are used as the rule head. The consistency verification module substitutes the candidate verification axioms into the current verification rule base to perform logical consistency checks, excludes candidate axioms with logical conflicts, and the generated supplementary verification axiom candidate schemes need to be confirmed by process personnel before being synchronized to the verification rule base.

[0050] To address logic and resource conflicts, the predicates of the flow axiom and the timing constraints are adjusted based on the predicate dependency graph to achieve semantic-level resolution of the conflicts and output a formally verified executable orchestration scheme.

[0051] The resolution process is executed in three steps. The first step is to locate the root cause of the conflict, which involves tracing all the flow axiom predicates and resource constraint predicates involved in the conflict in the predicate dependency graph, and identifying the core dependency edges and constraint nodes that caused the conflict. The second step is to classify and adjust. For resource-related conflicts, priority is given to adjusting the timing constraints of nodes. This is done by extending the execution time window of related nodes and adjusting the startup order of parallel nodes to resolve resource preemption. During the adjustment process, it is simultaneously verified whether the process constraint invariants are still globally satisfied. For logical conflicts, priority is given to adjusting the constraints of the flow axiom. This is done by narrowing the branch decision threshold and supplementing the convergence conditions of the pre-constraint predicates to resolve logical contradictions. After the adjustment, it is verified that the reachability of the entire path is not affected. The third step is validity verification. After the adjustments are completed, a lightweight model check is automatically triggered to confirm that the target conflict has been completely eliminated and no new logical vulnerabilities or coverage blind spots have been introduced. All adjustments are completed at the predicate semantic level and do not directly modify the topology of the main execution link.

[0052] In an industrial setting, a resource conflict arises when two machine tools simultaneously occupy the same hoisting equipment. This conflict is resolved by adjusting the start-up sequence of one of the machining nodes to stagger the equipment's usage time. At the same time, it is verified that the adjusted process flow still meets the production line's cycle time constraints.

[0053] In one embodiment of the present invention, the verified executable orchestration scheme is deployed to the runtime environment, and the scheduling agent triggers the process execution based on the event-driven mechanism. The execution process is based on the agent's behavior contract to maintain the contextual consistency between the execution data and the verification data. The scheduling agent maintains a global event queue, which includes four types of events: node ready events, device reporting events, verification completion events, and anomaly alarm events. All events are bound to the corresponding node's vector clock tag and state predicate version number upon generation and stored in the event queue in partial chronological order. In industrial scenarios, node readiness events are triggered by photoelectric sensor signals indicating material unloading completion at upstream workstations, equipment reporting events are triggered by equipment status data periodically reported by the production line PLC, and verification completion events are triggered when the verification agent outputs the verification result. After the scheduling agent retrieves the events in sequence, it matches the corresponding flow axioms based on the state predicate associated with the event and issues execution instructions to the target execution or verification agent. The instructions carry the corresponding data context references, and the agent performs the corresponding operation after completing parameter verification according to the behavior contract.

[0054] For multi-agent concurrent scenarios, the agent software layer uses a vector clock mechanism to tag data with global time sequence labels, while the physical device layer ensures device-level time sequence consistency through an industrial Ethernet clock synchronization protocol. Data synchronization is bound to the state predicate version number of the corresponding node. Before the verification agent starts verification, it simultaneously verifies the continuity of the time sequence labels and the semantic consistency of the state predicate, ensuring the spatiotemporal alignment of the verification data and the corresponding execution data. The dimension of the vector clock corresponds one-to-one with the number of agents in the orchestration link. When each agent performs a state update, the clock count value of the corresponding dimension of the agent is incremented. When the data flows, the current complete vector clock sequence is carried as a global time sequence label. The state predicate version number is bound to the vector clock value, and the version number is incremented synchronously each time the state predicate is updated.

[0055] Each state predicate of each task node maintains an independent version number sequence. When the state changes on the linear execution path, the version number increases monotonically in sequence. The state predicates on the branch path each maintain their own version number sequence independently, without interfering with each other.

[0056] When branch paths merge, the values ​​of multiple branch versions of the same state predicate are compared. If the values ​​of the predicates of each branch are completely consistent, a new merge version number is generated as the unified input state of the downstream node. If the values ​​are inconsistent, a state conflict check is triggered, and the decision-making agent determines whether the merge constraint is satisfied.

[0057] The state rollback operation comprises two stages: semantic state rollback and physical execution rollback. The semantic layer rolls back the version number of the corresponding state predicate to the target historical version and generates a unique rollback operation identifier. Subsequent new state changes continue to increment based on the rolled-back version, fully preserving the entire version evolution trajectory. The physical layer executes the material and equipment state reset for the corresponding workstation according to the semantic rollback scope, performing rollback operations only on nodes with causal dependencies.

[0058] In industrial scenarios, when two parallel pre-assembly stations merge, the output versions of the part dimensions and material status predicates of the two branches are verified respectively. After confirming that the parameters are consistent, a unified version number is generated after merging, and the process proceeds to the subsequent final assembly process.

[0059] Before verification, the verification agent first compares the vector clock partial order relationship between the verification data and the corresponding execution data to confirm the consistency of temporal causality, then verifies the matching of the state predicate version number, and starts the verification operation after confirming the consistency of the semantic context.

[0060] Vector clock causality consistency criterion: , This represents the vector clock sequence corresponding to each of the two data events. Each vector clock is an integer array of length n, and is also bound to the state predicate version number of the corresponding node. This represents the partial order relation of vector clocks. If the relation holds, it means that event a causally occurred before event b, and the two events have temporal continuity and causal consistency. This indicates logically equivalent operators, where the results of the judgments on both sides are completely equivalent; This indicates a universal quantifier, meaning that the condition on the right is satisfied for all subscript elements; The dimension index of the vector clock corresponds to the i-th agent instance in the orchestration link; The total dimension of the vector clock is equal to the total number of agents participating in the execution of the current link; , This represents the clock count value of the i-th agent in the corresponding event. The value of this dimension increases monotonically each time the agent updates the node state.

[0061] If the verification passes, the process proceeds to the next node according to the agent's behavior contract. If the verification fails, a retry, state rollback, or full-link circuit breaker is triggered based on the anomaly level. During rollback, all predicate nodes with dependent anomalies are traced back based on the predicate dependency graph. Only parallel branch nodes with non-causal dependencies retain their execution state. If an upstream node in a serial link fails, downstream related nodes must synchronously perform state rollback. A full-link semantic log containing state predicate version numbers, time series labels, and verification results is recorded throughout the entire process.

[0062] Anomalies are classified into three levels based on the level of the violated predicate and the scope of impact. Level 1 anomalies are minor deviations in non-critical process parameters, which only violate general quality constraint predicates and do not affect the core requirements of subsequent processes. The retry mechanism is triggered, and the execution agent resets the execution parameters of the current node and re-executes. A preset upper limit is set for the number of retries. Once the upper limit is reached, the anomaly is upgraded to Level 2. Level 2 anomalies occur when critical process parameters exceed tolerances or intermediate states do not satisfy flow axioms, violating core process constraint predicates. This triggers state rollback. The system traces upwards through the predicate dependency graph to all predicate nodes that depend on this anomaly state, rolling back only the state predicate of the corresponding node to the version before the change. The execution states of downstream unrelated nodes that have already been completed are retained. Level 3 anomalies occur when safety constraints are triggered or unrecoverable equipment state errors occur, violating safety-level invariant predicates, triggering full-link circuit breakers, and the scheduling agent issues shutdown commands to all execution nodes, locking the current full-link state and triggering on-site alarms.

[0063] In industrial settings, slight deviations in surface roughness are classified as Level 1 anomalies, substandard welding strength as Level 2 anomalies, and excessive equipment pressure as Level 3 anomalies.

[0064] Semantic logs are stored in structured entries. Each log entry contains nine categories of fields: unique identifier of workstation node, execution agent instance number, verification protocol number, state predicate snapshot set, vector clock timing label, predicate version number, verification raw data, exception level code, and processing action record.

[0065] The state predicate snapshot records all state predicate values ​​of the corresponding node at the time of log generation, verifies the measured values ​​collected by sensors in the industrial field and the equipment operating parameters of the original data, and maps all fields one by one with the semantic elements of the industrial task link meta-model through predicate identifiers. Log writing adopts append storage, and a corresponding log is generated every time a state transition or a verification operation is completed.

[0066] In one embodiment of the present invention, the execution and verification semantic logs of the entire chain are aggregated to construct an axiomatic semantic tracing chain, and each verification anomaly is mapped to the state predicate, the flow axiom predicate, or the independent intelligent agent behavior contract terms in the industrial task chain meta-model. When constructing the source tracing link, first extract three core identifiers from the semantic log: the node identifier corresponding to the verification anomaly, the verification specification number, and the status predicate version number. The first step is to locate the basic semantic elements of the meta-model that are abnormally associated by verifying the state predicate and process constraint predicate bound by the specification number in reverse association. The second step is to check whether there are semantic deviations in the flow conditions by matching the flow axiom predicate set that is effective at the corresponding time by matching the state predicate version number. The third step is to verify whether the input and output constraints of the contract match the semantics of the node by associating the corresponding behavior contract terms by the agent instance number.

[0067] Ultimately, a full-link mapping relationship is formed from exception log entries to specific predicates, axioms, and contract terms, with each mapping node retaining semantic identifiers and version information.

[0068] In industrial scenarios, for verification anomalies caused by out-of-tolerance machining dimensions, the traceability link first locates the predicate of the outer diameter dimension of the part and the predicate of the dimensional tolerance process constraint, then matches the post-flow axiom of the machining node, and finally associates the behavioral contract input parameter clauses of the dimension verification agent.

[0069] Inverse reasoning is performed based on the first-order predicate resolution principle to generate three types of root cause candidates: missing predicate definitions, loose axiom constraints, and incomplete contract terms. The root cause candidates need to be reviewed and confirmed by technical personnel to generate corresponding calibration schemes, such as generating model-level calibration schemes to supplement missing corresponding level predicates, correct axiom predicates with inconsistent constraint strength, and optimize the agent's behavior contract. The inverse reasoning takes the abnormal state predicate corresponding to the verification anomaly, the triggered flow axiom, and the associated agent contract terms as input. First, it deduces and deduces the abnormal facts and the existing set of predicate axioms.

[0070] If predicate terms that cannot be unified occur during the resolution process, it is determined that the predicate definition is missing; if the resolution result shows that the axiom constraints cannot cover abnormal boundary conditions, it is determined that the axiom constraints are too loose; if the input and output predicates of the agent contract cannot be unified with the node predicates during the resolution process, it is determined that the contract terms are incomplete, and a corresponding type of calibration scheme is generated based on the determination result.

[0071] Formal consistency verification uses all predicates, axioms, and contractual clauses involved in the calibration scheme as elements to be verified, and takes the complete axiomatic system of the currently effective industrial task link meta-model as the verification benchmark, performing verification from three dimensions.

[0072] The first dimension is syntax consistency verification, which checks whether the number and type of parameters of the predicate to be verified are consistent with the signature of the semantically identical predicate in the meta-model, so as to avoid predicate definitions that are semantically identical but have incompatible formats.

[0073] The second dimension is logical consistency verification, which involves substituting the axiom to be verified into the existing axiomatic system and performing a reduction and deduction to confirm that the same predicate will not be simultaneously derived into affirmative and negative conclusions, and that there is no logical contradiction.

[0074] The third dimension is constraint compatibility verification, which verifies that the newly added or adjusted constraints are not mutually exclusive with existing process invariants and resource constraints, and will not cause conflicts with process rules. If all three verifications pass, the calibration scheme is deemed legal, and the meta-model update can be performed.

[0075] In industrial scenarios, when adding a temperature upper limit constraint for a new heat treatment process, it is necessary to verify whether it conflicts with the existing maximum operating temperature constraint of the heat treatment equipment and the temperature resistance constraint of the workpiece material. The meta-model update is completed only after compatibility is confirmed.

[0076] After the calibration scheme undergoes formal consistency verification, the corresponding predicates and axioms in the industrial task link meta-model are updated and synchronized to all orchestration instances that reference the industrial task link meta-model.

[0077] In one embodiment of the present invention, the orchestration scheme that has been verified and runs stably in the field is abstracted into a reusable unit consisting of template fragments, a set of verification axioms, and a set of agent behavior contracts. The reusable unit is classified and deposited into a template knowledge base according to industrial scenarios and task types. The templates, axioms, and contracts in the reusable unit maintain semantic alignment. When a reusable unit is invoked, a three-step adaptation process is executed. The first step is node topology adaptation, which reads the node predicates of the industrial task link meta-model of the target task and performs semantic mapping with the built-in node predicates of the reusable unit to complete the node replacement and topology adjustment of the template fragment. The second step is to verify the axiom adaptation, which involves associating the set of verification axioms of reusable units with the corresponding nodes of the target task through predicate binding operators, and automatically adjusting the parameter thresholds and constraint strength of the axioms according to the process documents of the target scenario. The third step is agent verification, which involves synchronously matching agents of the corresponding categories and completing the compatibility verification of the behavior contract. After confirming that the preconditions and postconditions match, the deployment is completed.

[0078] In industrial settings, the calibration and orchestration units of automotive parts assembly stations can be adapted to electronic component assembly stations through predicate mapping. Only the threshold values ​​of process parameters such as size and torque need to be adjusted to quickly generate usable orchestration schemes.

[0079] Based on the incrementally accumulated execution and verification data, implicit process invariants and verification rules are extracted through association rule mining and transformed into formal axiom candidates. The axiom candidates need to be reviewed by process personnel and verified on-site, and then undergo axiom consistency verification to ensure that they have no logical conflict with the verification rule library. They are then incrementally expanded into the verification rule library and the industrial task link meta-model. The association rule mining uses the state predicate sequence, verification result data, and process parameter data in the full-link semantic log as input datasets. It adopts the frequent itemset mining method, sets support and confidence thresholds, and filters out state-process parameter association pairs that meet the thresholds.

[0080] The selected association pairs are mapped to process constraint predicates, and then transformed into formal axioms according to the predicate semantic specifications of the industrial task link meta-model. After consistency verification, these axioms are expanded into the verification rule base. The mining process prioritizes the aggregation of operational data from similar industrial scenarios.

[0081] Synchronously optimize the semantic axioms of the corresponding orchestration template and the behavior contract configuration of the agent, and generate defect correction suggestions for the same scenario for the defects of the industrial task link metamodel located in a single scenario. After manual confirmation, the suggestions are generalized and migrated to all orchestration templates and the industrial task link metamodel in the same scenario.

[0082] Before generalization and transfer, the similarity of the scenarios is first determined based on the process domain labels, task type labels, and constraint attribute labels of the industrial task link meta-model. If the label overlap reaches a preset threshold, the scenarios are considered to be of the same type.

[0083] The migration process involves three steps: First, defect element extraction, which extracts the corrected predicate definitions, axiomatic constraints, and contract terms corresponding to defects from the calibrated metamodel; second, batch matching traversal, which traverses all metamodels and orchestration templates of the same type to locate semantic elements with similar defect definitions; and third, incremental update and consistency verification, which performs the same correction operation on the matched semantic elements, generates formal consistency verification tasks one by one after correction, and confirms that the metamodels and templates without logical conflicts after correction are updated, while those with conflicts generate items for manual review.

[0084] In industrial scenarios, for defects in cutting speed constraints that are too loose in CNC lathe machining, the system automatically matches the meta-models of all metal cutting scenarios of the same type, batch corrects the parameter range of the corresponding process constraint predicates, and completes a full update after verifying that there are no conflicts, so as to avoid the same defect from recurring in different production line scenarios.

[0085] This invention also provides an intelligent agent workflow orchestration platform for task link verification in industrial scenarios. Based on the above method, it includes a semantic modeling unit, an intelligent agent contract management unit, an integrated orchestration generation unit, a formal verification unit, an operation control unit, a model calibration unit, and a system evolution unit. The semantic modeling unit uses first-order predicate logic to construct an industrial task link meta-model, decomposes industrial verification specifications into atomic verification specifications in the form of Horn clauses and establishes predicate mapping, constructs a verification rule base with semantic axioms, and supports automatic linkage of verification logic as the model topology changes. The agent contract management unit maintains a hierarchical agent role pool, defines standardized agent behavior contracts, and completes consistency matching and binding between agents and task nodes based on the semantics of the industrial task link meta-model. The integrated orchestration generation unit generates the execution main link topology based on the industrial task link meta-model and automatically locates the verification injection position. It weaves in the verification logic in a semantic aspect manner to generate an integrated orchestration model with unified execution and verification semantics. The formal verification unit transforms the integrated orchestration model into a finite state transition system. After state space reduction, it traverses the entire path through model detection, identifies and resolves logical conflicts and verification vulnerabilities, and outputs an executable orchestration scheme. The operation and control unit deploys the executable orchestration scheme and drives the collaborative execution of multiple agents. It maintains data context consistency based on the agent behavior contract, adopts a hierarchical timing guarantee mechanism to ensure the spatiotemporal alignment of data in concurrent scenarios, handles execution anomalies in a hierarchical manner, and records full-link semantic logs. The model calibration unit constructs a source tracing link based on the semantic log, deduces the root cause of the defect and generates a model-level calibration scheme, and realizes hot updates and full instance synchronization. The system evolution unit precipitates reusable orchestration units, and the implicit process rules are mined to expand the verification rule base.

[0086] It should be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus.

[0087] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for intelligent agent workflow orchestration for task link verification in industrial scenarios, characterized in that, The specific steps include the following: An industrial task link meta-model is constructed using first-order predicate logic. Standardized logical expressions for task node states, process constraint invariants, and flow dependency rules are defined. The industrial verification specification is decomposed into atomic verification specifications, and a mapping relationship is established between the atomic verification specifications and the industrial task link meta-model. A verification rule library with semantic axioms is constructed. Construct an intelligent agent role pool and define standardized intelligent agent behavior contracts. Based on the semantics of the industrial task link meta-model, complete the matching and binding of intelligent agents and task nodes to form a contractual correspondence. Based on the industrial task link meta-model, the main execution link topology is generated, the verification injection position is located, and the verification logic is woven in using semantic aspect to generate an integrated orchestration model. The integrated orchestration model is transformed into a finite state transition system. The core verification properties of the link operation are defined. The state space is reduced based on the process constraint predicates defined by the industrial task link meta-model. Logical conflicts and verification coverage vulnerabilities are identified and resolved. An executable orchestration scheme is output. The executable orchestration scheme is deployed to the runtime environment, and the process is executed based on event-driven triggering. The contextual consistency of execution and verification data is maintained through the standardized intelligent agent behavior contract, ensuring the spatiotemporal alignment of data in concurrent scenarios. The flow or exception handling is performed according to the verification result and semantic logs are recorded. Construct an axiomatic semantic tracing link, map the verification anomaly to the corresponding semantic elements of the industrial task link meta-model and the standardized agent behavior contract terms, distinguish the root causes of defects based on predicate logic inversion reasoning and generate a model-level calibration scheme, update the industrial task link meta-model after consistency verification and synchronize it to the associated orchestration instance. The stable orchestration scheme verified on-site is abstracted into reusable units and stored in the template knowledge base. The verification rule base is expanded based on the implicit process rules mined from the operational data.

2. The intelligent agent workflow orchestration method for task link verification in industrial scenarios according to claim 1, characterized in that, The industrial task link meta-model adopts a three-layer first-order predicate structure, from top to bottom: basic state predicate layer, process constraint predicate layer, and flow axiom predicate layer. The three layers correspond to three types of semantic elements: node state definition, process constraint invariant, and node flow axiom, respectively. The industrial verification specification is decomposed into atomic verification specifications in the form of Horn clauses. A one-to-one mapping relationship between the atomic verification specifications and the predicates of the task node states is established through predicate binding operators. After semantic axiomization, the rules are stored in the verification rule base. When the task link topology or flow conditions change, the system automatically adjusts the scope of action and triggering conditions of the verification axioms based on the predicate dependency graph, so that the verification logic can automatically link with the semantics of the industrial task link meta-model.

3. The intelligent agent workflow orchestration method for task link verification in industrial scenarios according to claim 2, characterized in that, The intelligent agent role pool adopts a layered architecture, including four types of roles: execution, verification, decision-making, and scheduling. The standardized intelligent agent behavior contracts of each type of intelligent agent clearly define the pre-trigger conditions, post-state guarantees, operational invariants, and data interaction interfaces. The standardized agent behavior contract for execution-type intelligent agents is automatically generated by the task node state predicate and flow axiom predicate of the industrial task link meta-model. The standardized agent behavior contract for verification-type intelligent agents is automatically generated by the Horn clause of the atomic verification specification. When matching agents and task nodes, the binding between the two is completed through a semantic consistency matching algorithm, while verifying the consistency of predicate signatures and constraint compatibility between the standardized agent behavior contract and the task node state predicate.

4. The intelligent agent workflow orchestration method for task link verification in industrial scenarios according to claim 3, characterized in that, After generating the main execution link topology based on the industrial task link meta-model, the three types of verification injection positions—state transition boundary, branch convergence point, and key process node—are located by calculating state transition entropy and identifying strongly connected components. After matching the corresponding atomic verification specification and verification class agent, the verification logic is woven into the state transition time of the task node in the manner of the semantic aspect. The verification sub-flow and the execution node share the state predicate context. Combined with the standardized agent behavior contract, the triggering sequence, data context and exception interface of the verification node are deduced to generate a semantically unified integrated orchestration model.

5. The intelligent agent workflow orchestration method for task link verification in industrial scenarios according to claim 4, characterized in that, The core verification properties of the link operation include four categories: no deadlock in the link, reachability of the entire path, global satisfaction of process constraint invariants, and completeness of verification rules. The equivalent states in the state space are clustered and reduced by the process constraint predicates in the industrial task link meta-model. When a verification coverage vulnerability is identified by model detection, the uncovered path is located by deducing the satisfiability of Horn clauses and the corresponding verification axiom is supplemented; when a logical or resource conflict is identified, the predicates of the flow axiom and the timing constraints are adjusted based on the predicate dependency graph to complete semantic-level resolution.

6. The intelligent agent workflow orchestration method for task link verification in industrial scenarios according to claim 5, characterized in that, In concurrent scenarios, the system uses a vector clock mechanism to add global time-series labels to the data and binds the state predicate version number of the corresponding node to the data. Before the verification agent starts verification, it verifies the continuity of the time-series labels and the semantic consistency of the state predicate. If the verification passes, the task will proceed to the next task node according to the standardized intelligent agent behavior contract. If the verification fails, a retry, state rollback, or full-link circuit breaker will be triggered according to the exception level. During rollback, only the subset of state predicates related to the exception will be rolled back, while the execution status of unrelated nodes will be retained. A semantic log containing state predicate version numbers, time sequence labels, and verification results will be recorded throughout the process.

7. The intelligent agent workflow orchestration method for task link verification in industrial scenarios according to claim 6, characterized in that, The axiomatic semantic tracing link maps the verification anomalies to the state predicate, the flow axiom predicate of the industrial task link meta-model, or the standardized agent behavior contract terms, respectively. Inverse reasoning is performed based on the first-order predicate resolution principle to distinguish three types of root causes: missing predicate definitions, loose axiom constraints, and incomplete contract terms. Correspondingly, a model-level calibration scheme is generated to supplement missing predicates, correct constraint strength, and optimize the standardized agent behavior contract. After consistency verification, the model-level calibration scheme updates the industrial task link meta-model and synchronizes it to all orchestration instances that reference the industrial task link meta-model.

8. The intelligent agent workflow orchestration method for task link verification in industrial scenarios according to claim 7, characterized in that, The reusable unit is a three-in-one structure of template fragment, verification axiom set, and standardized agent behavior contract set. It is classified and deposited into the template knowledge base according to industrial scenarios and task types. The elements within the reusable unit maintain semantic alignment. Based on incremental operational data, implicit process rules are extracted through association rule mining, transformed into formal verification axioms, and after consistency verification, incrementally expanded into the verification rule base and the industrial task link meta-model. At the same time, the defects of the industrial task link meta-model in a single scenario are generalized and migrated to all orchestration templates and industrial task link meta-models of the same scenario.

9. An intelligent agent workflow orchestration platform for task link verification in industrial scenarios, based on the method described in any one of claims 1-8, characterized in that, It includes the following units: The semantic modeling unit uses first-order predicate logic to construct the industrial task link meta-model, decomposes the industrial verification specification into the atomic verification specification, establishes a mapping relationship between the atomic verification specification and the industrial task link meta-model, and constructs the verification rule base with semantic axioms. The agent contract management unit maintains a hierarchical agent role pool, defines the standardized agent behavior contracts, and completes semantic matching and binding between agents and task nodes. An integrated orchestration generation unit generates the execution main link topology based on the industrial task link meta-model and locates the verification injection position, weaves verification logic in the semantic aspect method, and generates the integrated orchestration model. The formal verification unit transforms the integrated orchestration model into the finite state transition system. After state space reduction, it detects and resolves logical conflicts and verification vulnerabilities through the model and outputs the executable orchestration scheme. The operation and management unit deploys and drives the executable orchestration scheme to execute, maintains data context consistency, ensures data spatiotemporal alignment in concurrent scenarios, handles anomalies in a hierarchical manner, and records the semantic log. The model calibration unit constructs the axiomatic semantic tracing link based on the semantic log, derives the root cause of the defect and generates the model-level calibration scheme, updates the industrial task link meta-model and synchronizes it to the associated orchestration instance; The system evolution unit precipitates the reusable units and mines hidden process rules to expand the verification rule base.

10. The intelligent agent workflow orchestration platform for task link verification in industrial scenarios according to claim 9, characterized in that, The industrial task link meta-model constructed by the semantic modeling unit is a three-layer first-order predicate structure, and the decomposed atomic verification rule is in the form of a Horn clause, supporting automatic linkage adjustment of the verification logic as the topology of the industrial task link meta-model changes.

Images